class Blufin::YmlJavaEmbeddedObjectWriter

Constants

EMBEDDED_RESOURCE_DATA
EMBEDDED_SDK
PLACEHOLDER_BASE_IMPORT
PLACEHOLDER_CONTENT
PLACEHOLDER_ENUM
PLACEHOLDER_FIELD_NAME
PLACEHOLDER_FIELD_TYPE
PLACEHOLDER_OBJECT
PLACEHOLDER_OBJECT_LOWER
PLACEHOLDER_SERVICE
PLACEHOLDER_SITE_DOMAIN
PLACEHOLDER_SITE_NAME

Public Class Methods

new(site, schema_resources) click to toggle source

Initialize the class. @return void

# File lib/core/yml_writers/yml_java_embedded_object_writer.rb, line 21
        def initialize(site, schema_resources)

            @site             = Blufin::SiteResolver::validate_site(site)
            @site_name        = Blufin::SiteResolver::get_site_name(@site)
            @site_domain      = Blufin::SiteResolver::get_site_domain(@site)
            @site_domain_gsub = @site_domain.strip == '' ? '' : "#{@site_domain}."
            @site_location    = "#{Blufin::SiteResolver::get_site_location(@site)}/"
            @schema_resources = schema_resources
            @embedded         = Blufin::ScannerJavaEmbeddedObjects::EMBEDDED
            @embedded_data    = Blufin::SiteEmbedded::get_data
            @embedded_path    = "#{Blufin::Config::get_path('Paths', 'BlufinJava')}/#{Blufin::ScannerJavaEmbeddedObjects::PATH_TO_EMBEDDED}"
            @embedded_tables  = generate_embedded_tables_array
            @yml_enum_scanner = Blufin::ScannerJavaEnums.new(@site)

            # Wipe out all previous files.
            Blufin::YmlSchemaValidator::VALID_SCHEMAS_GENERATE.each do |schema|
                %W(
                #{@embedded_path}/base
                #{@embedded_path}/client
                #{@embedded_path}/field
                #{@embedded_path}/filter
                #{@embedded_path}/mapper
                #{@embedded_path}/metadata
                #{@embedded_path}/refiner
                #{@embedded_path}/service
                #{@embedded_path}/sort
                ).each do |path_to_wipe_out|
                    if Blufin::Files::path_exists(path_to_wipe_out)
                        if Blufin::Files::get_files_in_dir(path_to_wipe_out).any?
                            Blufin::Terminal::command('rm *', path_to_wipe_out, false, false) unless path_to_wipe_out == "#{@embedded_path}/dto" # Safe-guard to prevent accidental deletion of /dto folder.
                        end
                    end
                end
            end

            @template_embedded_sdk = <<TEMPLATE
package #{PLACEHOLDER_PACKAGE};

import org.blufin.sdk.base.ResourceData;
import org.blufin.sdk.service.BlufinApiService;
import org.blufin.sdk.service.credentials.ApiCredentialsHttp;
import org.blufin.sdk.service.credentials.ApiCredentialsInternal;
import org.springframework.stereotype.Service;
#{PLACEHOLDER_IMPORT}

@Service
public class #{PLACEHOLDER_CLASS} extends BlufinApiService {

    public void initialize(ResourceData resourceLocator) {

        initializeParent(new ApiCredentialsInternal(resourceLocator));
    }

    public void initialize(String authorizationHeader, String apiUri) {

        initializeParent(new ApiCredentialsHttp(authorizationHeader, apiUri));
    }
#{PLACEHOLDER_CONTENT}}
TEMPLATE

            @template_embedded_resource_data = <<TEMPLATE
package #{PLACEHOLDER_PACKAGE};

import org.blufin.base.annotations.Singleton;
import org.blufin.base.annotations.TestNotRequired;
import org.blufin.base.annotations.helper.ON;
import org.blufin.base.exceptions.BlufinClientException;
import org.blufin.base.exceptions.BlufinNotImplementedException;
import org.blufin.sdk.exceptions.ResourceNotFoundException;
import org.blufin.base.exceptions.BlufinServerException;
import org.blufin.sdk.base.AbstractMapperEmbedded;
import org.blufin.sdk.base.AbstractMetaData;
import org.blufin.sdk.base.PersistentDto;
import org.blufin.sdk.base.ResourceData;
import org.blufin.sdk.response.ApiResponse;
import org.blufin.sdk.rest.GetRequest;
import org.springframework.stereotype.Service;
import java.text.MessageFormat;
import lombok.Getter;
#{PLACEHOLDER_IMPORT}

@Service
public class #{PLACEHOLDER_CLASS} implements ResourceData {

    @Getter
    private static final #{PLACEHOLDER_CLASS} instance = new #{PLACEHOLDER_CLASS}();

    @Singleton
    private #{PLACEHOLDER_CLASS}() {}

    @Override
    public ApiResponse<? extends PersistentDto> executeGet(String endPoint, GetRequest getRequest) throws BlufinClientException, BlufinServerException {

        throw new BlufinNotImplementedException();
    }

    @Override
    public AbstractMetaData getMetaData(String endPoint) throws ResourceNotFoundException {

        throw new BlufinNotImplementedException();
    }

    @Override
    public int getDepth(String table) {

        throw new BlufinNotImplementedException();
    }

    public AbstractMapperEmbedded mapper(String responseDto) {

        switch (responseDto) {

#{PLACEHOLDER_CONTENT}
            default:
                throw new RuntimeException(MessageFormat.format("Unrecognized response DTO: {0}", responseDto));
        }
    }
}
TEMPLATE

            @template_service = <<TEMPLATE
package #{PLACEHOLDER_PACKAGE};

import org.blufin.base.helper.IdSet;
import org.blufin.sdk.base.AbstractService;
import org.blufin.sdk.service.credentials.ApiCredentials;
import org.blufin.sdk.embedded.dto.#{PLACEHOLDER_SCHEMA}.#{@embedded}#{PLACEHOLDER_OBJECT};
import org.blufin.sdk.embedded.field.#{@embedded}#{PLACEHOLDER_OBJECT}Field;
import org.blufin.sdk.embedded.metadata.#{@embedded}#{PLACEHOLDER_OBJECT}MetaData;
import org.blufin.sdk.embedded.sort.#{@embedded}#{PLACEHOLDER_OBJECT}Sort;
import org.blufin.sdk.embedded.refiner.#{@embedded}#{PLACEHOLDER_OBJECT}Refiner;
import org.blufin.sdk.request.IdSetGetRequest;
import org.blufin.sdk.request.PaginatedGetRequest;#{PLACEHOLDER_IMPORT}

public class #{PLACEHOLDER_CLASS} implements AbstractService {

    private final ApiCredentials apiCredentials;

    public #{PLACEHOLDER_CLASS}(ApiCredentials apiCredentials) {

        this.apiCredentials = apiCredentials;
    }

#{PLACEHOLDER_CONTENT}}
TEMPLATE

            @template_field = <<TEMPLATE
package #{PLACEHOLDER_PACKAGE};

import org.blufin.sdk.base.AbstractField;

public enum #{PLACEHOLDER_CLASS} implements AbstractField {
#{PLACEHOLDER_CONTENT}

    private final String fieldName;

    #{PLACEHOLDER_CLASS}(String fieldName) {

        this.fieldName = fieldName;
    }

    @Override
    public String getFieldName() {

        return fieldName;
    }
}
TEMPLATE

            @template_filter = <<TEMPLATE
package #{PLACEHOLDER_PACKAGE};

import org.blufin.sdk.base.AbstractFilter;

public enum #{PLACEHOLDER_CLASS} implements AbstractFilter {
#{PLACEHOLDER_CONTENT}

    private final String fieldName;

    #{PLACEHOLDER_CLASS}(String fieldName) {

        this.fieldName = fieldName;
    }

    @Override
    public String getFieldName() {

        return fieldName;
    }
}
TEMPLATE

            @template_mapper = <<TEMPLATE
package #{PLACEHOLDER_PACKAGE};

import lombok.Getter;
import org.blufin.sdk.base.AbstractMapperEmbedded;
import org.blufin.sdk.embedded.dto.#{PLACEHOLDER_SCHEMA}.#{@embedded}#{PLACEHOLDER_OBJECT};
#{PLACEHOLDER_IMPORT}

import java.lang.reflect.InvocationTargetException;

public final class #{PLACEHOLDER_CLASS} extends AbstractMapperEmbedded<#{@embedded}#{PLACEHOLDER_OBJECT}> {

    @Getter
    private static final #{PLACEHOLDER_CLASS} instance = new #{PLACEHOLDER_CLASS}();

    private #{PLACEHOLDER_CLASS}() {}

    @Override
    public #{@embedded}#{PLACEHOLDER_OBJECT} map(Object #{PLACEHOLDER_OBJECT_LOWER}) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {

        #{@embedded}#{PLACEHOLDER_OBJECT} #{@embedded.downcase}#{PLACEHOLDER_OBJECT} = new #{@embedded}#{PLACEHOLDER_OBJECT}();

#{PLACEHOLDER_CONTENT}

        return #{@embedded.downcase}#{PLACEHOLDER_OBJECT};
    }
}
TEMPLATE

            @template_refiner = <<TEMPLATE
package #{PLACEHOLDER_PACKAGE};

import org.blufin.base.annotations.TestNotRequired;
import org.blufin.base.annotations.NestedRefiner;
import org.blufin.sdk.base.AbstractRefiner;
import org.blufin.sdk.base.Refiner;
import org.blufin.sdk.filters.dynamic.*;
import org.blufin.sdk.request.PaginatedGetRequest;
import org.blufin.sdk.filters.Filter;
import org.blufin.sdk.embedded.dto.#{PLACEHOLDER_SCHEMA}.#{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE};
import org.blufin.sdk.embedded.field.#{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}Field;
import org.blufin.sdk.embedded.filter.#{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}Filter;
import org.blufin.sdk.embedded.sort.#{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}Sort;#{PLACEHOLDER_BASE_IMPORT}
import java.util.List;

@TestNotRequired
public class #{PLACEHOLDER_CLASS} extends Refiner<PaginatedGetRequest<#{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}, #{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}Field, #{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}Sort, #{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}Refiner>> implements AbstractRefiner {

    public #{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}Refiner(List<Filter> filters, PaginatedGetRequest<#{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}, #{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}Field, #{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}Sort, #{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}Refiner> originalRequest) {

        super(filters, originalRequest);
    }
#{PLACEHOLDER_CONTENT}}
TEMPLATE

            @template_sort = <<TEMPLATE
package #{PLACEHOLDER_PACKAGE};

import org.blufin.sdk.base.AbstractSort;

public enum #{PLACEHOLDER_CLASS} implements AbstractSort {
#{PLACEHOLDER_CONTENT}

    private final String fieldName;

    #{PLACEHOLDER_CLASS}(String fieldName) {

        this.fieldName = fieldName;
    }

    @Override
    public String getFieldName() {

        return fieldName;
    }

    @Override
    public String toString() {

        return this.name();
    }
}
TEMPLATE

        end

Public Instance Methods

get_refiner_content(schema, table, nest_level = 1) click to toggle source

Gets refiner content as a Hash of Arrays. @return string

# File lib/core/yml_writers/yml_java_embedded_object_writer.rb, line 790
def get_refiner_content(schema, table, nest_level = 1)
    content_data = []
    field_data   = @embedded_data[table][:data]
    field_data.keys.each do |key|

        @type = field_data[key][:type]

        # If this is a LINK field, skip.
        # TODO - 12/15/18 - Probably need to make changes here when we need to support Linked objects.
        next if @type == Blufin::ScannerJavaEmbeddedObjects::OBJECT_LINK

        # If this is a nested SINGLE/MULTIPLE, handle it.
        if @type == Blufin::ScannerJavaEmbeddedObjects::OBJECT_LIST
            key_split = field_data[key][:nested_table].gsub(/\[\]$/, '').split('.')
            content_data << ["#{nest_level + 1}.#{schema}.#{key_split[1]}"]
            get_refiner_content(schema, key_split[1], nest_level + 1)
            next
        end

        # TODO - If this field is ENCRYPTED, skip (for now).
        # TODO - Encrypted fields are possible, but need to be thought about when used across multiple apps.
        # TODO - The challenge is, how do we ensure we're using the same Encryption Key/IV?
        # TODO - And it needs to stay the same FOREVER! Probably means we have to hard-code it somewhere, somehow.
        raise RuntimeError, 'Encrypted fields not currently supported by @Embedded objects.' if field_data[key].has_key?(Blufin::YmlSchemaValidator::ENCRYPTED)

        if @type == Blufin::YmlSchemaValidator::TYPE_BOOLEAN
            filter = 'FilterBoolean'
        elsif @type == Blufin::YmlSchemaValidator::TYPE_DATE
            # Must come BEFORE ..DATETIME_TYPES.include?(@type) because the latter included DATE as well.
            filter = 'FilterDate'
        elsif Blufin::YmlSchemaValidator::DATETIME_TYPES.include?(@type)
            filter = 'FilterDateTime'
        elsif @type =~ Blufin::YmlSchemaValidator::REGEX_DECIMAL
            filter = 'FilterDecimal'
        elsif @type == Blufin::YmlSchemaValidator::TYPE_INT_BIG
            filter = 'FilterIntegerBig'
        elsif @type == Blufin::YmlSchemaValidator::TYPE_INT_TINY
            filter = 'FilterIntegerTiny'
        elsif @type == Blufin::YmlSchemaValidator::TYPE_INT_SMALL
            filter = 'FilterIntegerSmall'
        elsif Blufin::YmlSchemaValidator::INT_TYPES.include?(@type)
            filter = 'FilterInteger'
        elsif @type == Blufin::YmlSchemaValidator::TYPE_TEXT
            next if field_data[key].has_key?(:encrypted)
            filter = 'FilterText'
        elsif @type == Blufin::YmlSchemaValidator::TYPE_TEXT_LONG
            filter = 'FilterTextLong'
        elsif @type == Blufin::YmlSchemaValidator::TYPE_ENUM_SYSTEM
            filter      = 'FilterEnum'
            enum_class  = field_data[key][:type_java]
            enum_class  = enum_class.slice(0, 1).upcase + enum_class.slice(1..-1)
            enum_import = "import #{Blufin::SiteServices::PACKAGE_SYSTEM_ENUMS}.#{PLACEHOLDER_ENUM};"
            @content_data_import << enum_import.gsub(PLACEHOLDER_ENUM, enum_class)
            filterable_extra = ", #{enum_class}"
        elsif @type =~ Blufin::YmlSchemaValidator::REGEX_VARCHAR
            filter = 'FilterVarchar'
        elsif @type == Blufin::ScannerJavaEmbeddedObjects::OBJECT
            content_data << ["#{nest_level + 1}.#{schema}.#{key}"]
            get_refiner_content(schema, key, nest_level + 1)
            next
        else
            raise RuntimeError, "Unrecognized type in #{__FILE__} or field: #{key} \xe2\x86\x92 #{@type}"
        end
        key_cleaned = Blufin::YmlCommon::extract_field_name(key)
        content_data << [filter, Blufin::Strings::snake_case_to_camel_case_lower(key_cleaned), key_cleaned.upcase, filterable_extra]
    end
    @content_data_master["#{nest_level}.#{schema}.#{table}"] = content_data
end
write() click to toggle source

Write the file(s). @return void

# File lib/core/yml_writers/yml_java_embedded_object_writer.rb, line 301
def write

    write_embedded_base

    @embedded_data.each do |table, data|

        write_embedded_service(table, data)
        write_embedded_field(table, data)
        write_embedded_filter(table, data)
        write_embedded_mapper(table, data)
        write_embedded_metadata(table, data)
        write_embedded_refiner(table, data)
        write_embedded_sort(table, data)

    end

end
write_embedded_base() click to toggle source

Writes the Base Services -> EmbeddedSDK and EmbeddedResourceData @return void

# File lib/core/yml_writers/yml_java_embedded_object_writer.rb, line 321
def write_embedded_base

    write_embedded_sdk
    write_embedded_locator

end
write_embedded_field(table, data) click to toggle source

Write embedded Field classes. @return void

# File lib/core/yml_writers/yml_java_embedded_object_writer.rb, line 464
def write_embedded_field(table, data)

    schema      = data[:schema]
    class_name = "#{@embedded}#{data[:class]}Field"

    contents = @template_field
    contents = contents.gsub(PLACEHOLDER_PACKAGE, "org.blufin.sdk.embedded.field")
    contents = contents.gsub(PLACEHOLDER_CLASS, class_name)

    content      = "\n"
    content_data = []

    data[:data].keys.each do |key|
        next if key =~ /\A(#{Blufin::YmlSchemaValidator::VALID_SCHEMAS_REGEX})\.[a-z_]+\z/ || key =~ /\A(#{Blufin::YmlSchemaValidator::VALID_SCHEMAS_REGEX})\.[a-z_]+\[(link)?\]\z/
        content_data << [Blufin::YmlCommon::extract_field_name(key)]
    end

    content_data.each_with_index do |cd, idx|
        comma_or_not = (idx == (content_data.length - 1)) ? ';' : ",\n"
        content      += "    #{cd[0].upcase}(\"#{table}.#{cd[0]}\")#{comma_or_not}"
    end

    contents = contents.gsub(PLACEHOLDER_CONTENT, content)

    write_file("field/#{class_name}.java", contents, schema == Blufin::YmlSchemaValidator::MOCK)

end
write_embedded_filter(table, data) click to toggle source

Write embedded Filter classes. @return void

# File lib/core/yml_writers/yml_java_embedded_object_writer.rb, line 494
def write_embedded_filter(table, data)

    schema      = data[:schema]
    class_name = "#{@embedded}#{data[:class]}Filter"

    contents = @template_filter
    contents = contents.gsub(PLACEHOLDER_PACKAGE, 'org.blufin.sdk.embedded.filter')
    contents = contents.gsub(PLACEHOLDER_CLASS, class_name)

    content      = "\n"
    content_data = []

    data[:data].each do |key, data_inner|
        next if key =~ /\A(#{Blufin::YmlSchemaValidator::VALID_SCHEMAS_REGEX})\.[a-z_]+\z/ || key =~ /\A(#{Blufin::YmlSchemaValidator::VALID_SCHEMAS_REGEX})\.[a-z_]+\[(link)?\]\z/
        next if data_inner.has_key?(:encrypted)
        content_data << [Blufin::YmlCommon::extract_field_name(key)]
    end

    content_data.each_with_index do |cd, idx|
        comma_or_not = (idx == (content_data.length - 1)) ? ';' : ",\n"
        content      += "    #{cd[0].upcase}(\"#{table}.#{cd[0]}\")#{comma_or_not}"
    end

    contents = contents.gsub(PLACEHOLDER_CONTENT, content)

    write_file("filter/#{class_name}.java", contents, schema == Blufin::YmlSchemaValidator::MOCK)

end
write_embedded_locator() click to toggle source
# File lib/core/yml_writers/yml_java_embedded_object_writer.rb, line 355
def write_embedded_locator

    contents          = @template_embedded_resource_data
    contents_inner    = []
    import_statements = []

    @embedded_data.each do |key, data|
        embedded_object = Blufin::Strings::snake_case_to_camel_case(key)
        import_statements << "import org.blufin.sdk.embedded.mapper.#{@embedded}#{embedded_object}Mapper;"
        contents_inner << "case \"#{@embedded}#{embedded_object}\":"
        contents_inner << "    return #{@embedded}#{embedded_object}Mapper.getInstance();"
    end

    contents_inner.map! { |n| "            #{n}" }
    contents = contents.gsub(PLACEHOLDER_PACKAGE, 'org.blufin.sdk.embedded.base')
    contents = contents.gsub(PLACEHOLDER_CLASS, EMBEDDED_RESOURCE_DATA)
    contents = contents.gsub(PLACEHOLDER_CONTENT, contents_inner.join("\n"))
    contents = contents.gsub(PLACEHOLDER_IMPORT, import_statements.join("\n"))

    write_file("base/#{EMBEDDED_RESOURCE_DATA}.java", contents, false)
end
write_embedded_mapper(table, data) click to toggle source

Write embedded Mapper classes. @return void

# File lib/core/yml_writers/yml_java_embedded_object_writer.rb, line 525
def write_embedded_mapper(table, data)

    method_body       = []
    import_statements = []

    data[:data].each do |key, data_inner|

        field_camel_case = Blufin::Strings.snake_case_to_camel_case(key)

        @type = data_inner[:type]

        # If this is a LINK field, skip.
        # TODO - 12/15/18 - Probably need to make changes here when we need to support Linked objects.
        next if @type == Blufin::ScannerJavaEmbeddedObjects::OBJECT_LINK

        # TODO - If this field is ENCRYPTED, skip (for now).
        raise RuntimeError, 'Encrypted fields not currently supported by @Embedded objects.' if data_inner.has_key?(Blufin::YmlSchemaValidator::ENCRYPTED)

        if @type == Blufin::YmlSchemaValidator::TYPE_BOOLEAN
            method_body << "#{@embedded.downcase}#{PLACEHOLDER_OBJECT}.set#{field_camel_case}((Boolean) #{PLACEHOLDER_OBJECT_LOWER}.getClass().getMethod(\"is#{field_camel_case}\").invoke(#{PLACEHOLDER_OBJECT_LOWER}));"
        elsif @type == Blufin::YmlSchemaValidator::TYPE_DATE # Must come BEFORE ..DATETIME_TYPES.include?(@type) because the latter included DATE as well.
            import_statements << 'import java.time.LocalDate;'
            method_body << "#{@embedded.downcase}#{PLACEHOLDER_OBJECT}.set#{field_camel_case}((LocalDate) #{PLACEHOLDER_OBJECT_LOWER}.getClass().getMethod(\"get#{field_camel_case}\").invoke(#{PLACEHOLDER_OBJECT_LOWER}));"
        elsif Blufin::YmlSchemaValidator::DATETIME_TYPES.include?(@type)
            import_statements << 'import java.time.ZonedDateTime;'
            method_body << "#{@embedded.downcase}#{PLACEHOLDER_OBJECT}.set#{field_camel_case}((ZonedDateTime) #{PLACEHOLDER_OBJECT_LOWER}.getClass().getMethod(\"get#{field_camel_case}\").invoke(#{PLACEHOLDER_OBJECT_LOWER}));"
        elsif @type =~ Blufin::YmlSchemaValidator::REGEX_DECIMAL
            import_statements << 'import java.math.BigDecimal;'
            method_body << "#{@embedded.downcase}#{PLACEHOLDER_OBJECT}.set#{field_camel_case}((BigDecimal) #{PLACEHOLDER_OBJECT_LOWER}.getClass().getMethod(\"get#{field_camel_case}\").invoke(#{PLACEHOLDER_OBJECT_LOWER}));"
        elsif @type == Blufin::YmlSchemaValidator::TYPE_INT_BIG
            method_body << "#{@embedded.downcase}#{PLACEHOLDER_OBJECT}.set#{field_camel_case}((Long) #{PLACEHOLDER_OBJECT_LOWER}.getClass().getMethod(\"get#{field_camel_case}\").invoke(#{PLACEHOLDER_OBJECT_LOWER}));"
        elsif @type == Blufin::YmlSchemaValidator::TYPE_INT_TINY
            method_body << "#{@embedded.downcase}#{PLACEHOLDER_OBJECT}.set#{field_camel_case}((Byte) #{PLACEHOLDER_OBJECT_LOWER}.getClass().getMethod(\"get#{field_camel_case}\").invoke(#{PLACEHOLDER_OBJECT_LOWER}));"
        elsif @type == Blufin::YmlSchemaValidator::TYPE_INT_SMALL
            method_body << "#{@embedded.downcase}#{PLACEHOLDER_OBJECT}.set#{field_camel_case}((Short) #{PLACEHOLDER_OBJECT_LOWER}.getClass().getMethod(\"get#{field_camel_case}\").invoke(#{PLACEHOLDER_OBJECT_LOWER}));"
        elsif Blufin::YmlSchemaValidator::INT_TYPES.include?(@type)
            method_body << "#{@embedded.downcase}#{PLACEHOLDER_OBJECT}.set#{field_camel_case}((Integer) #{PLACEHOLDER_OBJECT_LOWER}.getClass().getMethod(\"get#{field_camel_case}\").invoke(#{PLACEHOLDER_OBJECT_LOWER}));"
        elsif @type == Blufin::YmlSchemaValidator::TYPE_TEXT
            next if data_inner.has_key?(:encrypted)
            method_body << "#{@embedded.downcase}#{PLACEHOLDER_OBJECT}.set#{field_camel_case}((String) #{PLACEHOLDER_OBJECT_LOWER}.getClass().getMethod(\"get#{field_camel_case}\").invoke(#{PLACEHOLDER_OBJECT_LOWER}));"
        elsif @type == Blufin::YmlSchemaValidator::TYPE_TEXT_LONG
            method_body << "#{@embedded.downcase}#{PLACEHOLDER_OBJECT}.set#{field_camel_case}((String) #{PLACEHOLDER_OBJECT_LOWER}.getClass().getMethod(\"get#{field_camel_case}\").invoke(#{PLACEHOLDER_OBJECT_LOWER}));"
        elsif @type == Blufin::YmlSchemaValidator::TYPE_ENUM_SYSTEM
            enum_class = data_inner[:type_java]
            enum_class = enum_class.slice(0, 1).upcase + enum_class.slice(1..-1)
            import_statements << "import #{Blufin::SiteServices::PACKAGE_SYSTEM_ENUMS}.#{enum_class};"
            method_body << "#{@embedded.downcase}#{PLACEHOLDER_OBJECT}.set#{field_camel_case}((#{enum_class}) #{PLACEHOLDER_OBJECT_LOWER}.getClass().getMethod(\"get#{field_camel_case}\").invoke(#{PLACEHOLDER_OBJECT_LOWER}));"
        elsif @type =~ Blufin::YmlSchemaValidator::REGEX_VARCHAR
            method_body << "#{@embedded.downcase}#{PLACEHOLDER_OBJECT}.set#{field_camel_case}((String) #{PLACEHOLDER_OBJECT_LOWER}.getClass().getMethod(\"get#{field_camel_case}\").invoke(#{PLACEHOLDER_OBJECT_LOWER}));"
        elsif @type == Blufin::ScannerJavaEmbeddedObjects::OBJECT
            type_java_stripped = data_inner[:type_java].strip.gsub(/^List</, '').gsub(/>$/, '')
            method_body << "#{@embedded.downcase}#{PLACEHOLDER_OBJECT}.#{"set#{type_java_stripped}".gsub(/^set#{@embedded}/, 'set')}(mapObject(#{PLACEHOLDER_OBJECT_LOWER}, \"#{"get#{type_java_stripped}".gsub(/^get#{@embedded}/, 'get')}\", #{type_java_stripped}Mapper.getInstance()));"
        elsif @type == Blufin::ScannerJavaEmbeddedObjects::OBJECT_LIST
            type_java_stripped = data_inner[:type_java].strip.gsub(/^List</, '').gsub(/>$/, '')
            method_body << "#{@embedded.downcase}#{PLACEHOLDER_OBJECT}.#{"set#{type_java_stripped}".gsub(/^set#{@embedded}/, 'set')}List(mapList(#{PLACEHOLDER_OBJECT_LOWER}, \"#{"get#{type_java_stripped}List".gsub(/^get#{@embedded}/, 'get')}\", #{type_java_stripped}Mapper.getInstance()));"
        else
            raise RuntimeError, "Unrecognized type in #{__FILE__} or field: #{key} \xe2\x86\x92 #{@type}"
        end
    end

    import_statements.uniq!
    import_statements.sort!

    method_body.map! { |n| "        #{n}" }

    schema     = data[:schema]
    class_name = "#{@embedded}#{data[:class]}Mapper"

    contents = @template_mapper
    contents = contents.gsub(PLACEHOLDER_PACKAGE, 'org.blufin.sdk.embedded.mapper')
    contents = contents.gsub(PLACEHOLDER_CLASS, class_name)
    contents = contents.gsub(PLACEHOLDER_SCHEMA, schema)
    contents = contents.gsub(PLACEHOLDER_CONTENT, method_body.join("\n"))
    contents = contents.gsub(PLACEHOLDER_OBJECT, data[:class])
    contents = contents.gsub(PLACEHOLDER_OBJECT_LOWER, data[:class][0, 1].downcase + data[:class][1..-1])
    contents = contents.gsub(PLACEHOLDER_IMPORT, import_statements.join("\n"))

    write_file("mapper/#{class_name}.java", contents, schema == Blufin::YmlSchemaValidator::MOCK)

end
write_embedded_metadata(table, data) click to toggle source

Write embedded Metadata classes. @return void

# File lib/core/yml_writers/yml_java_embedded_object_writer.rb, line 608
def write_embedded_metadata(table, data)

    @import_statements = ['import org.blufin.sdk.base.AbstractMetaData;', 'import org.blufin.base.enums.DataType;']
    @child_type        = nil

    consts = []
    fields = []
    schema = data[:schema]

    table_data = data[:data]
    table_data.each do |column_name, column_data|

        @type                 = nil
        @flag                 = nil
        @fkey                 = nil
        @link                 = nil
        @encrypted            = nil
        @max_length           = nil
        @transient            = nil
        @child_of             = nil
        @description          = nil
        @required             = nil
        @required_if          = nil
        @decimal_distribution = nil
        @enum_name            = nil
        @enum_values          = nil

        # Handle Placeholders
        if column_data[:type] == Blufin::ScannerJavaEmbeddedObjects::OBJECT_LIST
            column_name_dup = "#{column_name.dup.gsub('[]', '').split('.')[1]}_list"
            consts << "    public static final String FIELD_#{column_name_dup.upcase} = \"#{column_name_dup}\";"
            fields << "        metaData.put(FIELD_#{column_name_dup.upcase}, new HashMap<String, Object>() {{"
        elsif column_data[:type] == Blufin::ScannerJavaEmbeddedObjects::OBJECT_LINK
            column_name_dup = "#{column_name.dup.gsub("[#{Blufin::YmlSchemaValidator::LINK}]", '').split('.')[1]}_list"
            consts << "    public static final String FIELD_#{column_name_dup.upcase} = \"#{column_name_dup}\";"
            fields << "        metaData.put(FIELD_#{column_name_dup.upcase}, new HashMap<String, Object>() {{"
        else
            consts << "    public static final String FIELD_#{column_name.upcase} = \"#{column_name}\";"
            fields << "        metaData.put(FIELD_#{column_name.upcase}, new HashMap<String, Object>() {{"
        end

        unless column_data.nil?

            column_data.each do |key, value|

                case key.to_s
                    when Blufin::YmlSchemaValidator::DESCRIPTION
                        handle_description(value)
                    when Blufin::YmlSchemaValidator::TYPE
                        handle_type(value, schema, table, column_name, column_data)
                    when Blufin::YmlSchemaValidator::FLAG
                        handle_flag(value.join(' '))
                    when Blufin::YmlSchemaValidator::FKEY
                        handle_fkey(value)
                    when Blufin::YmlSchemaValidator::REQUIRED
                        handle_required(schema, table, value, table_data)
                    when Blufin::YmlSchemaValidator::REQUIRED_IF
                        handle_required_if(schema, table, value, table_data)
                    when Blufin::YmlSchemaValidator::ENCRYPTED
                        handle_encrypted(value)
                    when Blufin::YmlSchemaValidator::TRANSIENT
                        handle_transient(value)
                    when Blufin::YmlSchemaValidator::CHILD_OF
                        handle_child_of(value)
                    when Blufin::YmlSchemaValidator::CHILD_TYPE # For constructor parameter(s).
                        handle_child_type(value)
                    when Blufin::ScannerJavaEmbeddedObjects::KEY_NESTED_TABLE
                    when Blufin::ScannerJavaEmbeddedObjects::KEY_TYPE_JAVA
                        # Do Nothing.
                    else
                        raise RuntimeError, "Unrecognized column key in #{__FILE__}: #{key}"
                end

            end

        end

        # Handle fields that don't have a 'type' -- IE: Where type is automatically implied.
        handle_type_where_implied(table, column_name)

        # Check for critical errors...
        raise RuntimeError, "A MetaData field would've rendered without a 'TYPE' \xe2\x86\x92 #{schema}.#{table} \xe2\x86\x92 #{column_name}" if @type.nil?

        fields << @type unless @type.nil?
        fields << @flag unless @flag.nil?
        fields << @fkey unless @fkey.nil?
        fields << @link unless @link.nil?
        fields << @encrypted unless @encrypted.nil?
        fields << @max_length unless @max_length.nil?
        fields << @transient unless @transient.nil?
        fields << @child_of unless @child_of.nil?
        fields << @description unless @description.nil?
        fields << @required unless @required.nil?
        fields << @required_if unless @required_if.nil?
        fields << @decimal_distribution unless @decimal_distribution.nil?
        fields << @enum_name unless @enum_name.nil?
        fields << @enum_values unless @enum_values.nil?
        fields << "        }});\n"

    end

    hierarchy_result      = extract_hierarchy(schema, table, data[:dependents], @embedded_tables)
    hierarchy             = hierarchy_result[0]
    hierarchy_nested_only = hierarchy_result[1]

    class_name     = "#{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{Blufin::Strings::snake_case_to_camel_case(table)}#{Blufin::YmlJavaMetaWriter::META_DATA}"
    content        = ['package org.blufin.sdk.embedded.metadata;', '']
    full_file_path = "#{@embedded_path}/metadata/#{class_name}.java"

    # Generate the content. Shared method between Embedded and non-embedded writers.
    content        = generate_content(content, 'Embedded', consts, fields, hierarchy, hierarchy_nested_only, schema, table, class_name, @import_statements, @child_type)

    # Write the file.
    write_file_java(full_file_path, content, schema == Blufin::YmlSchemaValidator::MOCK).gsub(@site_location, '')

end
write_embedded_refiner(table, data) click to toggle source

Write embedded Refiner classes. @return void

# File lib/core/yml_writers/yml_java_embedded_object_writer.rb, line 727
        def write_embedded_refiner(table, data)

            @content             = "\n"
            @content_nested      = {}
            schema               = data[:schema]
            table                = data[:table]
            service              = Blufin::Strings::snake_case_to_camel_case(data[:table])
            class_name           = "#{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{service}Refiner"
            full_file_path       = "#{@embedded_path}/refiner/#{class_name}.java"
            @content_data_import = []
            @content_data_master = {}

            get_refiner_content(schema, table)

            # Sort Hash by keys (alphabetically).
            @content_data_master = Hash[@content_data_master.sort_by { |key| key }]
            @content_data_master.each do |first_key, content_data|
                write_refiner_content(first_key, content_data, service)
                break
            end

            contents = @template_refiner
            contents = contents.gsub(PLACEHOLDER_PACKAGE, 'org.blufin.sdk.embedded.refiner')
            contents = contents.gsub(PLACEHOLDER_CLASS, class_name)

            base_import_statements = "\n"

            @content_data_import.uniq!
            @content_data_import.sort!
            @content_data_import.each { |content_import_statement| base_import_statements += "#{content_import_statement}\n" }

            @content_nested.each do |key, data_inner|
                key_split = key.split('.')
                nc_cc     = Blufin::Strings::snake_case_to_camel_case(key_split[2])
                content   = <<CLASS
    @NestedRefiner
    public static class #{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{nc_cc}Refiner extends Refiner<PaginatedGetRequest<#{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}, #{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}Field, #{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}Sort, #{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}Refiner>> implements AbstractRefiner {

        public #{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{nc_cc}Refiner(List<Filter> filters, PaginatedGetRequest<#{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}, #{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}Field, #{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}Sort, #{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}Refiner> originalRequest) {

            super(filters, originalRequest);
        }

#{PLACEHOLDER_CONTENT}    }

CLASS
                content  = content.gsub(PLACEHOLDER_CONTENT, data_inner.chomp)
                @content += content
            end

            contents = contents.gsub(PLACEHOLDER_CONTENT, @content.chomp)
            contents = contents.gsub(PLACEHOLDER_SERVICE, service)
            contents = contents.gsub(PLACEHOLDER_SCHEMA, schema)
            contents = contents.gsub(PLACEHOLDER_SITE_NAME, @site_name.gsub('-', '.'))
            contents = contents.gsub(PLACEHOLDER_SITE_DOMAIN, @site_domain_gsub)
            contents = contents.gsub(PLACEHOLDER_BASE_IMPORT, base_import_statements)

            write_file_java(full_file_path, Blufin::YmlCommon::convert_string_to_line_array(contents), schema == Blufin::YmlSchemaValidator::MOCK)

        end
write_embedded_sdk() click to toggle source

@return void

# File lib/core/yml_writers/yml_java_embedded_object_writer.rb, line 329
        def write_embedded_sdk

            contents          = @template_embedded_sdk
            import_statements = []
            service_getters   = ''

            @embedded_data.each do |key, data|
                service         = Blufin::Strings::snake_case_to_camel_case(key)
                service_getters += <<TEMPLATE

    public #{@embedded}#{service}Service get#{@embedded}#{service}Service() {

        return new #{@embedded}#{service}Service(getApiCredentials());
    }
TEMPLATE
                import_statements << "import org.blufin.sdk.embedded.service.#{@embedded}#{service}Service;"
            end

            contents = contents.gsub(PLACEHOLDER_PACKAGE, 'org.blufin.sdk.embedded.base')
            contents = contents.gsub(PLACEHOLDER_CLASS, EMBEDDED_SDK)
            contents = contents.gsub(PLACEHOLDER_CONTENT, service_getters)
            contents = contents.gsub(PLACEHOLDER_IMPORT, import_statements.join("\n"))

            write_file("base/#{EMBEDDED_SDK}.java", contents, false)
        end
write_embedded_service(table, data) click to toggle source

Write embedded Service classes. @return void

# File lib/core/yml_writers/yml_java_embedded_object_writer.rb, line 379
        def write_embedded_service(table, data)

            schema  = data[:schema]
            service = data[:class]

            class_name = "#{@embedded}#{service}Service"
            class_auth = Blufin::SiteAuth::get_auth_level_for_table(schema, table)

            import_statements = []

            end_point = data[:table].gsub('_', '-')

            contents = @template_service
            contents = contents.gsub(PLACEHOLDER_PACKAGE, 'org.blufin.sdk.embedded.service')
            contents = contents.gsub(PLACEHOLDER_CLASS, class_name)
            contents = contents.gsub(PLACEHOLDER_SCHEMA, schema)

            case class_auth
                when Blufin::SiteAuth::LEVEL_NONE
                    content_inner = <<TEMPLATE
    public PaginatedGetRequest<#{@embedded}#{service}, #{@embedded}#{service}Field, #{@embedded}#{service}Sort, #{@embedded}#{service}Refiner> get() {

        return new PaginatedGetRequest<>(apiCredentials, "#{end_point}", #{@embedded}#{service}.class, #{@embedded}#{service}MetaData.getInstance(), #{@embedded}#{service}Refiner.class);
    }

    public IdSetGetRequest<#{@embedded}#{service}, #{@embedded}#{service}Field, #{@embedded}#{service}Sort> get(IdSet idSet) {

        return new IdSetGetRequest<>(apiCredentials, "#{end_point}", #{@embedded}#{service}.class, #{@embedded}#{service}MetaData.getInstance(), idSet);
    }

    public IdSetGetRequest<#{@embedded}#{service}, #{@embedded}#{service}Field, #{@embedded}#{service}Sort> get(int id) {

        return new IdSetGetRequest<>(apiCredentials, "#{end_point}", #{@embedded}#{service}.class, #{@embedded}#{service}MetaData.getInstance(), new IdSet(id));
    }
TEMPLATE
                when Blufin::SiteAuth::LEVEL_ACCOUNT
                    import_statements << 'import org.blufin.sdk.request.type.AccountRequest;'
                    content_inner = <<TEMPLATE
    public AccountRequest<PaginatedGetRequest<#{@embedded}#{service}, #{@embedded}#{service}Field, #{@embedded}#{service}Sort, #{@embedded}#{service}Refiner>> get() {

        return new AccountRequest(apiCredentials, "#{end_point}", #{@embedded}#{service}.class, #{@embedded}#{service}MetaData.getInstance(), #{@embedded}#{service}Refiner.class);
    }

    public AccountRequest<IdSetGetRequest<#{@embedded}#{service}, #{@embedded}#{service}Field, #{@embedded}#{service}Sort>> get(IdSet idSet) {

        return new AccountRequest(apiCredentials, "#{end_point}", #{@embedded}#{service}.class, #{@embedded}#{service}MetaData.getInstance(), idSet);
    }

    public AccountRequest<IdSetGetRequest<#{@embedded}#{service}, #{@embedded}#{service}Field, #{@embedded}#{service}Sort>> get(int id) {

        return new AccountRequest(apiCredentials, "#{end_point}", #{@embedded}#{service}.class, #{@embedded}#{service}MetaData.getInstance(), new IdSet(id));
    }
TEMPLATE
                when Blufin::SiteAuth::LEVEL_ACCOUNT_USER
                    import_statements << 'import org.blufin.sdk.request.type.AccountUserRequest;'
                    content_inner = <<TEMPLATE
    public AccountUserRequest<PaginatedGetRequest<#{@embedded}#{service}, #{@embedded}#{service}Field, #{@embedded}#{service}Sort, #{@embedded}#{service}Refiner>> get() {

        return new AccountUserRequest(apiCredentials, "#{end_point}", #{@embedded}#{service}.class, #{@embedded}#{service}MetaData.getInstance(), #{@embedded}#{service}Refiner.class);
    }

    public AccountUserRequest<IdSetGetRequest<#{@embedded}#{service}, #{@embedded}#{service}Field, #{@embedded}#{service}Sort>> get(IdSet idSet) {

        return new AccountUserRequest(apiCredentials, "#{end_point}", #{@embedded}#{service}.class, #{@embedded}#{service}MetaData.getInstance(), idSet);
    }

    public AccountUserRequest<IdSetGetRequest<#{@embedded}#{service}, #{@embedded}#{service}Field, #{@embedded}#{service}Sort>> get(int id) {

        return new AccountUserRequest(apiCredentials, "#{end_point}", #{@embedded}#{service}.class, #{@embedded}#{service}MetaData.getInstance(), new IdSet(id));
    }
TEMPLATE
                else
                    raise RuntimeError, "Unrecognized AuthLevel for table: #{class_auth}"
            end

            contents = contents.gsub(PLACEHOLDER_CONTENT, content_inner)
            contents = contents.gsub(PLACEHOLDER_IMPORT, import_statements.any? ? "\n#{import_statements.join("\n")}" : '')
            contents = contents.gsub(PLACEHOLDER_OBJECT, data[:class])

            write_file("service/#{class_name}.java", contents, schema == Blufin::YmlSchemaValidator::MOCK)

        end
write_embedded_sort(table, data) click to toggle source

Write embedded Sort classes. @return void

# File lib/core/yml_writers/yml_java_embedded_object_writer.rb, line 911
def write_embedded_sort(table, data)

    schema     = data[:schema]
    class_name = "#{@embedded}#{data[:class]}Sort"

    contents = @template_sort
    contents = contents.gsub(PLACEHOLDER_PACKAGE, 'org.blufin.sdk.embedded.sort')
    contents = contents.gsub(PLACEHOLDER_CLASS, class_name)

    content      = "\n"
    content_data = []

    data[:data].each do |key, data_inner|
        next if key =~ /\A(#{Blufin::YmlSchemaValidator::VALID_SCHEMAS_REGEX})\.[a-z_]+\z/ || key =~ /\A(#{Blufin::YmlSchemaValidator::VALID_SCHEMAS_REGEX})\.[a-z_]+\[(link)?\]\z/
        next if data_inner.has_key?(:encrypted)
        next if [
            Blufin::YmlSchemaValidator::TYPE_BOOLEAN,
            Blufin::YmlSchemaValidator::TYPE_TEXT,
            Blufin::YmlSchemaValidator::TYPE_TEXT_LONG
        ].include?(data_inner['type'])
        content_data << [Blufin::YmlCommon::extract_field_name(key)]
    end

    content_data.each_with_index do |cd, idx|
        comma_or_not = (idx == (content_data.length - 1)) ? ';' : ",\n"
        content      += "    #{cd[0].upcase}(\"#{table}.#{cd[0]}\")#{comma_or_not}"
    end

    contents = contents.gsub(PLACEHOLDER_CONTENT, content)

    write_file("sort/#{class_name}.java", contents, schema == Blufin::YmlSchemaValidator::MOCK)

end
write_refiner_content(content_key, content_data, service_inner, nest_level = 1) click to toggle source

Adds method data to @content & @content_nested Arrays. @return void

# File lib/core/yml_writers/yml_java_embedded_object_writer.rb, line 861
        def write_refiner_content(content_key, content_data, service_inner, nest_level = 1)

            nest_space = nest_level == 1 ? '    ' : '        '

            content_data.each do |cd|

                if cd.length == 1
                    cd_split = cd[0].split('.')
                    cd_cc    = Blufin::Strings::snake_case_to_camel_case(cd_split[2])
                    cd_ccl   = Blufin::Strings::snake_case_to_camel_case_lower(cd_split[2])
                    @content_data_import << "import org.blufin.sdk.embedded.filter.#{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{cd_cc}Filter;"
                    write_refiner_content(cd[0], @content_data_master[cd[0]], cd_cc, nest_level + 1)
                    content = <<METHOD
#{nest_space}public #{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}Refiner.#{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{cd_cc}Refiner #{cd_ccl}() {

#{nest_space}    return new #{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}Refiner.#{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{cd_cc}Refiner(getFilters(), getOriginalRequest());
#{nest_space}}

METHOD
                    if nest_level == 1
                        @content += content
                    else
                        @content_nested[content_key] = '' if @content_nested[cd].nil?
                        @content_nested[content_key] += content
                    end

                    next
                end

                content = ''
                content += <<METHOD
#{nest_space}public #{cd[0]}<PaginatedGetRequest<#{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}, #{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}Field, #{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}Sort, #{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{PLACEHOLDER_SERVICE}Refiner>#{cd[3]}> #{cd[1]}() {

#{nest_space}    return new #{cd[0]}<>(#{Blufin::ScannerJavaEmbeddedObjects::EMBEDDED}#{service_inner}Filter.#{cd[2]}, getFilters(), getOriginalRequest());
#{nest_space}}

METHOD
                if nest_level == 1
                    @content += content
                else
                    @content_nested[content_key] = '' if @content_nested[content_key].nil?
                    @content_nested[content_key] += content
                end

            end

        end

Private Instance Methods

generate_embedded_tables_array() click to toggle source

Generates an array of schema/table pairs separated by a dot (.) IE: An Array like [app.data_center, app.db, common.cron]… @return Array

# File lib/core/yml_writers/yml_java_embedded_object_writer.rb, line 956
def generate_embedded_tables_array
    embedded_tables = []
    @embedded_data.each do |key, value|
        embedded_tables << "#{value[:schema]}.#{key}"
    end
    embedded_tables.uniq!
    embedded_tables.sort!
    embedded_tables
end
write_file(file_from_embedded_path, contents, is_mock) click to toggle source

Write a file and add to Git. This method is already aware of the @embedded_path. @return void

# File lib/core/yml_writers/yml_java_embedded_object_writer.rb, line 949
def write_file(file_from_embedded_path, contents, is_mock)
    write_file_java("#{@embedded_path}/#{file_from_embedded_path}", Blufin::YmlCommon::convert_string_to_line_array(contents), is_mock)
end