tessl/maven-com-liferay-portal--com-liferay-portal-impl

Core implementation module containing the fundamental services, utilities, and infrastructure components for the Liferay Digital Experience Platform.

—

Pending

Overview

Eval results

Files

Utility Services

Name: tessl/maven-com-liferay-portal--com-liferay-portal-impl
Author: tessl

Core utilities including formatting, minification, file operations, XML processing, and portal-specific utility implementations providing essential support services for the Liferay portal framework.

Capabilities

Core Portal Utilities

Essential utility implementations for portal configuration, file operations, localization, and layout management.

/**
 * Portal utility class providing common portal operations
 */
public class PortalUtil {
    
    /**
     * Gets portal URL for the current request
     * @param request HTTP servlet request
     * @return portal URL string
     */
    public static String getPortalURL(HttpServletRequest request);
    
    /**
     * Gets current user from request
     * @param request HTTP servlet request
     * @return User object or null if not found
     */
    public static User getUser(HttpServletRequest request);
    
    /**
     * Gets company ID from request
     * @param request HTTP servlet request
     * @return company ID
     */
    public static long getCompanyId(HttpServletRequest request);
    
    /**
     * Escapes HTML content for safe output
     * @param content content to escape
     * @return HTML-escaped content
     */
    public static String escapeHTML(String content);
    
    /**
     * Unescapes HTML entities
     * @param content HTML content to unescape
     * @return unescaped content
     */
    public static String unescapeHTML(String content);
}

/**
 * File utility class for file operations
 */
public class FileUtil {
    
    /**
     * Reads file content as string
     * @param file file to read
     * @return file content as string
     * @throws IOException if file cannot be read
     */
    public static String read(File file) throws IOException;
    
    /**
     * Writes string content to file
     * @param file target file
     * @param content content to write
     * @throws IOException if file cannot be written
     */
    public static void write(File file, String content) throws IOException;
    
    /**
     * Copies file from source to destination
     * @param source source file
     * @param destination destination file
     * @throws IOException if copy fails
     */
    public static void copy(File source, File destination) throws IOException;
    
    /**
     * Gets file extension
     * @param fileName file name
     * @return file extension or empty string
     */
    public static String getExtension(String fileName);
    
    /**
     * Creates directories if they don't exist
     * @param directory directory to create
     * @return true if directory exists or was created
     */
    public static boolean mkdirs(File directory);
}

Text and Content Formatting

Text and content formatting utilities for various data types and output formats.

/**
 * Format utility class for text and content formatting
 */
public class FormatUtil {
    
    /**
     * Formats date using specified pattern
     * @param date date to format
     * @param pattern date format pattern
     * @param locale locale for formatting
     * @return formatted date string
     */
    public static String formatDate(Date date, String pattern, Locale locale);
    
    /**
     * Formats number using locale-specific formatting
     * @param number number to format
     * @param locale locale for formatting
     * @return formatted number string
     */
    public static String formatNumber(Number number, Locale locale);
    
    /**
     * Formats currency amount
     * @param amount currency amount
     * @param currencyCode currency code (USD, EUR, etc.)
     * @param locale locale for formatting
     * @return formatted currency string
     */
    public static String formatCurrency(double amount, String currencyCode, Locale locale);
    
    /**
     * Formats file size in human-readable format
     * @param sizeInBytes file size in bytes
     * @return formatted size string (KB, MB, GB)
     */
    public static String formatFileSize(long sizeInBytes);
    
    /**
     * Truncates text to specified length with ellipsis
     * @param text text to truncate
     * @param maxLength maximum length
     * @return truncated text with ellipsis if needed
     */
    public static String truncate(String text, int maxLength);
}

CSS and JavaScript Minification

Asset minification services for optimizing CSS and JavaScript resources.

/**
 * CSS minification service
 */
public class CSSMinifier {
    
    /**
     * Minifies CSS content by removing whitespace and comments
     * @param css CSS content to minify
     * @return minified CSS content
     */
    public static String minify(String css);
    
    /**
     * Minifies CSS file and saves to output file
     * @param inputFile input CSS file
     * @param outputFile output minified CSS file
     * @throws IOException if file operations fail
     */
    public static void minifyFile(File inputFile, File outputFile) throws IOException;
    
    /**
     * Compresses CSS with advanced optimizations
     * @param css CSS content to compress
     * @param aggressive true for aggressive compression
     * @return compressed CSS content
     */
    public static String compress(String css, boolean aggressive);
}

/**
 * JavaScript minification service
 */
public class JavaScriptMinifier {
    
    /**
     * Minifies JavaScript content
     * @param javascript JavaScript content to minify
     * @return minified JavaScript content
     */
    public static String minify(String javascript);
    
    /**
     * Minifies JavaScript file and saves to output file
     * @param inputFile input JavaScript file
     * @param outputFile output minified JavaScript file
     * @throws IOException if file operations fail
     */
    public static void minifyFile(File inputFile, File outputFile) throws IOException;
    
    /**
     * Obfuscates JavaScript code
     * @param javascript JavaScript content to obfuscate
     * @return obfuscated JavaScript content
     */
    public static String obfuscate(String javascript);
}

File Upload Processing

File upload processing utilities for handling multipart form data and file uploads.

/**
 * File upload utility for processing multipart requests
 */
public class UploadUtil {
    
    /**
     * Processes multipart request and extracts uploaded files
     * @param request HTTP servlet request with multipart data
     * @return Map of parameter names to uploaded files
     * @throws IOException if upload processing fails
     */
    public static Map<String, FileItem> processUpload(HttpServletRequest request) 
        throws IOException;
    
    /**
     * Gets uploaded file from request parameter
     * @param request HTTP servlet request
     * @param parameterName form parameter name
     * @return FileItem representing uploaded file
     */
    public static FileItem getFileItem(HttpServletRequest request, String parameterName);
    
    /**
     * Validates uploaded file against security constraints
     * @param fileItem uploaded file item
     * @param allowedExtensions allowed file extensions
     * @param maxSizeInBytes maximum file size
     * @return true if file passes validation
     */
    public static boolean validateUpload(FileItem fileItem, String[] allowedExtensions, 
        long maxSizeInBytes);
    
    /**
     * Saves uploaded file to specified directory
     * @param fileItem uploaded file item
     * @param destinationDir destination directory
     * @return saved file instance
     * @throws IOException if save operation fails
     */
    public static File saveUploadedFile(FileItem fileItem, File destinationDir) 
        throws IOException;
}

/**
 * File item representing an uploaded file
 */
public interface FileItem {
    
    /**
     * Gets original filename as uploaded by client
     * @return original filename
     */
    String getFileName();
    
    /**
     * Gets content type of uploaded file
     * @return MIME content type
     */
    String getContentType();
    
    /**
     * Gets size of uploaded file in bytes
     * @return file size in bytes
     */
    long getSize();
    
    /**
     * Gets uploaded file content as byte array
     * @return file content bytes
     */
    byte[] getBytes();
    
    /**
     * Gets input stream for reading file content
     * @return InputStream for file content
     * @throws IOException if stream cannot be created
     */
    InputStream getInputStream() throws IOException;
}

XML Processing and Manipulation

XML processing and manipulation utilities for working with XML documents and data.

/**
 * XML utility class for XML processing operations
 */
public class XMLUtil {
    
    /**
     * Parses XML string into Document object
     * @param xmlContent XML content as string
     * @return parsed Document object
     * @throws XMLException if parsing fails
     */
    public static Document parseXML(String xmlContent) throws XMLException;
    
    /**
     * Converts Document object to XML string
     * @param document XML document
     * @return XML content as string
     */
    public static String documentToString(Document document);
    
    /**
     * Evaluates XPath expression against XML document
     * @param document XML document
     * @param xpathExpression XPath expression
     * @return evaluation result
     * @throws XPathException if evaluation fails
     */
    public static Object evaluateXPath(Document document, String xpathExpression) 
        throws XPathException;
    
    /**
     * Transforms XML using XSLT stylesheet
     * @param xmlDocument source XML document
     * @param xsltStylesheet XSLT stylesheet
     * @return transformed XML result
     * @throws TransformationException if transformation fails
     */
    public static String transform(Document xmlDocument, String xsltStylesheet) 
        throws TransformationException;
    
    /**
     * Validates XML against XSD schema
     * @param xmlContent XML content to validate
     * @param xsdSchema XSD schema for validation
     * @return true if XML is valid
     * @throws ValidationException if validation process fails
     */
    public static boolean validateXML(String xmlContent, String xsdSchema) 
        throws ValidationException;
}

/**
 * XML configuration reader for portal configuration files
 */
public class XMLConfigurationReader {
    
    /**
     * Reads configuration from XML file
     * @param configFile XML configuration file
     * @return Configuration object
     * @throws ConfigurationException if reading fails
     */
    public static Configuration readConfiguration(File configFile) 
        throws ConfigurationException;
    
    /**
     * Gets configuration property value
     * @param configuration configuration object
     * @param propertyPath dot-separated property path
     * @return property value or null if not found
     */
    public static String getProperty(Configuration configuration, String propertyPath);
    
    /**
     * Gets configuration property as list
     * @param configuration configuration object
     * @param propertyPath dot-separated property path
     * @return list of property values
     */
    public static List<String> getPropertyList(Configuration configuration, String propertyPath);
}

Usage Examples

Portal Utilities:

// Get portal information from request
String portalURL = PortalUtil.getPortalURL(request);
User currentUser = PortalUtil.getUser(request);
long companyId = PortalUtil.getCompanyId(request);

// HTML escaping for safe output
String userInput = request.getParameter("comment");
String safeOutput = PortalUtil.escapeHTML(userInput);

File Operations:

// File reading and writing
File configFile = new File("/path/to/config.properties");
String content = FileUtil.read(configFile);

// Modify content
String updatedContent = content.replace("old.value", "new.value");
FileUtil.write(configFile, updatedContent);

// File copying
File source = new File("/source/file.txt");
File destination = new File("/destination/file.txt");
FileUtil.copy(source, destination);

Text Formatting:

// Date formatting
Date now = new Date();
String formattedDate = FormatUtil.formatDate(now, "yyyy-MM-dd HH:mm:ss", Locale.US);

// Number formatting
double amount = 1234.56;
String formattedAmount = FormatUtil.formatCurrency(amount, "USD", Locale.US);

// File size formatting
long fileSize = 1024 * 1024 * 5; // 5 MB
String readableSize = FormatUtil.formatFileSize(fileSize); // "5.0 MB"

Asset Minification:

// CSS minification
String cssContent = FileUtil.read(new File("styles.css"));
String minifiedCSS = CSSMinifier.minify(cssContent);
FileUtil.write(new File("styles.min.css"), minifiedCSS);

// JavaScript minification
String jsContent = FileUtil.read(new File("script.js"));
String minifiedJS = JavaScriptMinifier.minify(jsContent);
FileUtil.write(new File("script.min.js"), minifiedJS);

File Upload Processing:

// Process multipart upload
Map<String, FileItem> uploads = UploadUtil.processUpload(request);
FileItem uploadedFile = uploads.get("fileUpload");

if (uploadedFile != null) {
    // Validate upload
    String[] allowedTypes = {".jpg", ".png", ".gif"};
    boolean isValid = UploadUtil.validateUpload(uploadedFile, allowedTypes, 1024 * 1024); // 1MB max
    
    if (isValid) {
        // Save file
        File uploadDir = new File("/uploads");
        File savedFile = UploadUtil.saveUploadedFile(uploadedFile, uploadDir);
    }
}

XML Processing:

// Parse XML
String xmlContent = "<config><setting name='timeout'>30</setting></config>";
Document doc = XMLUtil.parseXML(xmlContent);

// XPath evaluation
String timeout = (String) XMLUtil.evaluateXPath(doc, "//setting[@name='timeout']/text()");

// XML transformation
String xsltStylesheet = "..."; // XSLT content
String transformedXML = XMLUtil.transform(doc, xsltStylesheet);

Integration with Portal Framework

Utility services provide foundational support for:

Content Management - File operations and XML processing
Asset Optimization - CSS/JS minification for performance
User Interface - Text formatting and HTML escaping
File Management - Upload processing and validation
Configuration - XML configuration reading and processing
Internationalization - Locale-aware formatting utilities

Error Handling

Common utility exceptions:

IOException - File operation failures
XMLException - XML parsing and processing errors
ConfigurationException - Configuration reading failures
ValidationException - Input validation errors
TransformationException - XSLT transformation failures

Best practices include proper exception handling, input validation, resource cleanup, and comprehensive logging for debugging and monitoring utility operations.

Install with Tessl CLI

npx tessl i tessl/maven-com-liferay-portal--com-liferay-portal-impl

docs

bean-management.md

database-orm.md

database-upgrades.md

framework-integration.md

template-processing.md

utility-services.md

web-security.md

tile.json

tessl/maven-com-liferay-portal--com-liferay-portal-impl