About IDE
The Magentrix Integrated Development Environment (IDE) is a comprehensive development platform that enables administrators with developer expertise to create, customize, and manage portal components using a unified interface. This browser-based development tool provides access to all essential customization elements including pages, templates, controllers, classes, triggers, and static assets without requiring navigation through multiple administrative menus.
The IDE features an intuitive tabbed interface that supports simultaneous work on multiple development elements, integrated debugging tools, and direct access to entity schemas and translation labels. Organizations can leverage the IDE to build custom user experiences, implement business logic, integrate external systems, and extend portal functionality beyond standard configuration options while maintaining centralized control over development activities.
Accessing the IDE
To access the Integrated Development Environment:
- Click on your avatar in the portal header
- Select Setup from the dropdown menu
- Navigate to the Develop section in the sidebar
- Click on IDE
The IDE opens in the current browser tab, replacing the Setup interface with the full development environment.
Core Functionality
Development Environment Structure
Tabbed Interface Management: The IDE provides a familiar multi-tab interface that enables developers to work on multiple pages, controllers, classes, and triggers simultaneously. Tabs can be opened, closed, and managed independently while maintaining unsaved work status indicators that prompt for confirmation before discarding changes.
Sidebar Navigation: Comprehensive sidebar organization provides quick access to all development elements including Pages, Templates, Contents, Controllers & Classes, Triggers, Static Assets, Entities, and Labels. Expandable tree structures enable efficient navigation through related elements and folder hierarchies.
Search Capabilities: Global search functionality enables developers to quickly locate specific pages, templates, content pages, controllers, classes, and triggers by name or keyword. Search results provide immediate access to desired elements without manual navigation through folder structures.
Page Development Options
Active Pages with Controllers: Active Pages represent the primary development option for creating dynamic, interactive portal experiences with full controller support. These pages combine HTML markup with C# controller logic following the Model-View-Controller (MVC) architecture pattern, enabling complex business logic implementation, data manipulation, and user interaction handling.
Templates for Reusable Layouts: Templates provide purely HTML-based page structures designed for reuse across multiple portal areas without controller logic. Organizations use templates to establish consistent visual frameworks, standardized layouts, and shared design elements that maintain brand consistency while reducing development time.
Content Pages with WYSIWYG Editing: Content Pages offer a what-you-see-is-what-you-get (WYSIWYG) editing experience designed for administrators who need to create HTML pages without writing code directly. This option provides visual editing tools while generating valid HTML output suitable for portal deployment.
Code Development and Logic
Controller Implementation: Controllers provide the business logic layer behind Active Pages, implementing the C# code that processes user inputs, queries data, performs calculations, and determines page behavior. Each Active Page can have one associated controller that executes server-side logic before rendering the page to users. The IDE automatically appends "Controller" to controller names, ensuring consistent naming conventions across development projects.
Class Development for Code Reusability: Classes enable developers to create modular, reusable code components that can be referenced across multiple controllers, triggers, and other classes. This approach supports efficient code organization, reduces duplication, and enables centralized maintenance of common business logic and utility functions used throughout portal customization.
Trigger Creation for Entity Events: Triggers implement event-driven logic that executes automatically when specific entity records are created, updated, or deleted. Developers can create multiple triggers for the same entity, enabling complex business rules, data validation, automated notifications, and integration workflows that respond to data changes throughout the portal ecosystem.
Static Asset Management
Folder Organization Structure: The Static Assets section provides hierarchical folder management for organizing JavaScript files, CSS stylesheets, and image resources. Developers can create nested folder structures without depth limitations, enabling logical organization based on project requirements, functionality groupings, or organizational standards.
Asset Upload and Management: File upload capabilities support all common web asset types including JavaScript (.js), CSS (.css), and image formats. Assets can be renamed, deleted, or moved between folders through context menu operations. No file size restrictions apply, providing flexibility for comprehensive resource libraries.
Automated Code Insertion: When developers add static assets to open Active Pages or Templates, the IDE automatically inserts properly formatted HTML code referencing the selected asset. JavaScript files generate script tags, CSS files generate link tags, and images generate img tags with correct path references, reducing manual coding requirements and syntax errors.
Entity Schema Browser
Comprehensive Entity Exploration: The Entity Browser provides read-only access to complete Magentrix entity schemas including all standard and custom entities available within the organization's portal. Developers can explore entity structures, field definitions, data types, and relationships without switching to administrative setup menus or external documentation.
Relationship Visualization: Child Relationships display all entities that reference the selected entity through lookup or master-detail relationships. This visualization helps developers understand data model connections, navigate complex schemas, and identify available relationship fields for queries and data manipulation logic.
Field Name Insertion: Right-click context menus on any entity field enable direct insertion of field names into open code files at the current cursor position. This feature eliminates the need to memorize or manually type field API names, reducing errors and accelerating development workflows.
Integrated Development Tools
Event Log for Debugging: The Event Log tool provides real-time visibility into custom code execution, errors, and developer-inserted log statements. Since the IDE does not include interactive debugging capabilities, the Event Log serves as the primary debugging mechanism, enabling developers to trace execution flow, identify errors, and verify logic implementation through strategically placed log statements.
Query Console for Data Exploration: The Query Console enables developers to execute Magentrix SQL queries directly within the IDE, providing immediate visibility into entity data without requiring external database tools or custom page development. This tool supports data verification, query syntax testing, and schema exploration during development activities.
Font Icon Library: The built-in Font Icon library provides browsable access to commonly used glyphicons suitable for portal user interface enhancement. Developers can view available icons, access HTML code for icon implementation through tooltips, and manually copy icon markup for use in Active Pages and Templates.
Code Editing Capabilities
Syntax Highlighting: The code editor provides automatic syntax highlighting for HTML, CSS, JavaScript, and C# code, improving code readability and reducing syntax errors through visual differentiation of language elements, keywords, strings, and comments.
Code Validation on Save: When developers save pages, controllers, classes, or triggers, the IDE performs automatic code validation and compilation. Validation errors display with specific line numbers and error descriptions at the bottom of the editor, enabling immediate identification and correction of syntax errors, type mismatches, and other code issues.
Find and Replace Functionality: Built-in find and replace tools enable efficient code searching and bulk modifications within individual files. Developers can locate specific text patterns, navigate between occurrences, and perform replacements without external text editing tools.
Undo and Redo Operations: Standard undo and redo capabilities support iterative development and error recovery through keyboard shortcuts (Ctrl+Z / Command+Z for undo, Ctrl+Y / Command+Y for redo). These operations enable developers to experiment with code changes while maintaining the ability to revert modifications.
Translation Label Integration
Label Reference Library: The Labels section displays all available translation labels configured within the organization's Translation Studio, providing developers with immediate access to user-facing text elements. Labels support multi-language portal implementations by separating display text from code logic.
Label Search and Insertion: Developers can search the complete label library and insert label references into code through right-click context menus. This integration ensures consistent use of approved translations, reduces hardcoded text strings, and supports internationalization requirements without manual label name management.
Translation Studio Integration: While labels cannot be created or edited directly within the IDE, clear integration with Translation Studio enables developers to identify needed labels during development and coordinate with administrators to create required label definitions through the appropriate administrative interface. [Link to Translation Studio documentation]
Administrative Management
Access Requirements and Permissions
Administrator Role Requirement: Only users assigned to the Administrator role can access the Integrated Development Environment. This permission model ensures that portal customization capabilities remain restricted to authorized personnel with appropriate technical expertise and organizational authorization while protecting portal stability and security.
Development Workflow Management: Administrators can work simultaneously on multiple development elements through the tabbed interface while maintaining independent save states for each open item. Unsaved changes receive visual indicators and prompt for confirmation before closing tabs, preventing accidental loss of development work.
File and Element Management
Creating New Elements: The File menu provides consolidated access to create new Pages (Active Pages, Templates, or Content Pages), Controllers, Classes, and Triggers. Each creation dialog requires specific naming inputs and configuration options appropriate to the element type, with automatic naming conventions applied where applicable.
Opening and Editing Existing Elements: Developers open existing pages, controllers, classes, and triggers by double-clicking items in the sidebar navigation tree or through right-click context menus. Multiple elements can remain open simultaneously in separate tabs, enabling cross-referencing and efficient movement between related development artifacts.
Deletion and Cleanup: Right-click context menus on sidebar items provide deletion options for pages, templates, content pages, controllers, classes, triggers, and static assets. Deletions require confirmation to prevent accidental removal of active portal components that may be in use by portal users.
Window and Navigation Management
Multi-Tab Workflow: Developers can maintain multiple open tabs for different pages, controllers, classes, and triggers, switching between development contexts through tab selection. The tab bar displays element names with file type indicators, and each tab includes a close button that prompts for save confirmation when unsaved changes exist.
Setup Menu Access: The Window menu provides direct access to the Administrator Setup menu in a new browser tab, enabling quick switching between development activities and administrative configuration tasks without losing IDE workspace state or closing active development tabs.
Home Tab Navigation: Developers can open the portal home page in a new browser tab through the Window menu, supporting preview activities, testing of deployed changes, and verification of user-facing functionality without exiting the development environment or disrupting active IDE sessions.
Tab Management Options: The Window menu includes a "Close All Tabs" function that closes all open development tabs after confirming save operations for any files with unsaved changes. This feature enables quick workspace clearing when transitioning between projects or development sessions.
IDE Exit and Session Management
Exit Functionality: The File menu's Exit option returns developers to the portal home page, closing the IDE interface and all open tabs. If any files contain unsaved changes, the system prompts for save confirmation before navigation, ensuring no development work is lost through premature exits.
No Automatic Save: The IDE does not include automatic save functionality. Developers must explicitly save work through save buttons or keyboard shortcuts. This design provides complete control over when code compilation and validation occur while requiring disciplined save practices to prevent loss of development progress.
Implementation Considerations
Development Best Practices
Code Organization Strategy: Developers should create dedicated classes for business logic that requires reuse across multiple controllers or triggers, maintaining separation between page-specific controller logic and shared utility functions. Consistent folder structures within Static Assets support efficient resource management and team collaboration.
Debugging Through Event Logs: Since interactive debugging is unavailable, developers should implement comprehensive logging strategies using Event Log entries during development. Log statements should capture execution flow, variable states, and conditional logic outcomes. Production code should remove or disable logging to prevent performance impacts and log table growth.
Asset Naming Conventions: Static assets should follow consistent naming conventions that indicate purpose, functionality, and version information. Organized folder hierarchies prevent naming conflicts, enable efficient asset location, and support long-term maintainability as customization libraries grow over time.
URL Path Planning: Active Page and Template paths should follow consistent patterns that reflect site structure and functionality. Path planning should consider user-facing URL readability, search engine optimization requirements, and logical organization of related pages within the /aspx/ namespace.
Performance and Maintenance
Event Log Cleanup: Regular review and clearing of Event Logs prevents database growth and maintains system performance. Development logging should be removed from production code after testing completion to prevent continuous log generation that impacts portal response times and database storage.
Code Validation Discipline: Developers should save and validate code frequently during development sessions to identify syntax errors, compilation issues, and type mismatches early in the development process. Error messages provide specific line numbers and descriptions that enable rapid correction before complex code interdependencies develop.
Static Asset Optimization: Image files, JavaScript libraries, and CSS stylesheets should be optimized for web delivery before upload to minimize page load times and bandwidth consumption. Minified JavaScript and CSS files reduce file sizes while maintaining functionality, improving portal performance for all users.
Security and Access Control
Administrator-Only Access: The IDE's restriction to Administrator role holders ensures that only authorized personnel with appropriate technical skills and organizational trust can modify portal functionality. This security model protects against unauthorized customization, accidental damage, and malicious code insertion.
Code Review Practices: Organizations should implement code review processes for IDE-developed customizations, ensuring quality standards, security best practices, and architectural consistency. Peer review identifies potential issues before deployment and maintains knowledge distribution across development teams.
Testing Before Deployment: All pages, controllers, classes, and triggers developed in the IDE should undergo comprehensive testing in non-production environments before activation in user-facing portals. Testing should verify functional requirements, error handling, edge cases, and integration points with existing portal functionality.
Limitations and Considerations
No Code Autocomplete: The IDE code editor does not provide autocomplete suggestions or IntelliSense-style assistance. Developers must have strong knowledge of Magentrix object models, C# syntax, and entity schemas or leverage the Entity Browser and documentation for field name and relationship references.
Limited Debugging Capabilities: The absence of interactive debugging tools requires developers to rely on Event Log statements for execution tracing and error identification. This limitation demands disciplined logging practices and systematic testing approaches to identify and resolve code issues efficiently.
Manual Icon HTML Copying: The Font Icon library does not include a copy-to-clipboard function. Developers must manually copy HTML code from icon tooltips for use in pages and templates, which can be prone to transcription errors if not carefully executed.
Single Entity per Trigger: Each trigger creation associates with a single specific entity, though multiple triggers can be created for the same entity. Complex multi-entity logic requires separate trigger implementations or consolidated handling through shared class methods called from multiple triggers.
No Label Editing: Translation labels displayed in the IDE sidebar are read-only references that cannot be created or modified within the development environment. Label management requires coordination with Translation Studio administrators, potentially introducing workflow dependencies when new labels are needed during development.
IDE Checklist >>