User Profile Details – Click Here
In this training video, we will learn how to design and configure the User Profile screen for the Smart Vendor & Procurement System (SVPS) using redSling Builder. This session covers the complete profile interface structure, including personal information, account details, notification preferences, security settings, and business-related information. We will then move into the Logic Builder to connect the profile interface with the logged-in user’s stored data.
The training is divided into two parts. In the first part, we build the User Profile interface using the UI Builder, organizing the page into a profile information panel and a main settings area. In the second part, we configure the logic required to retrieve user information from local storage, access the authentication token from session storage, extract individual profile properties, and populate the corresponding fields automatically.
By the end of this session, you will understand how to structure a user profile page and use component instances, variables, storage blocks, JSON parsing, and property-setting blocks to connect the interface with the application’s existing user information.
We begin by opening the UserProfile page in the redSling Builder UI Builder from the project workspace.
The page is designed to help users view and manage their account information, preferences, notification settings, and security details. It follows the existing application structure, with system navigation on the left and the main profile content on the right.
This provides a consistent foundation for building the profile interface alongside the other screens in the Smart Vendor & Procurement System.
The User Profile page begins with a header containing the title “User Profile” and the supporting description “Manage your account settings and preferences.”
Below the header, the main profile area is divided into two sections. The left panel contains the user’s profile image and basic account information, while the right section is dedicated to the profile settings form.
This separation creates a clear distinction between the user’s identity information and the settings available for management.
Next, we configure the main page header by adding the title, supporting description, and an Edit button positioned on the right side.
The Edit button serves as the primary entry point for editing profile information. The header is kept visually simple so that users can easily identify the purpose of the page and focus on the information displayed below it.
We then create the profile information panel on the left side of the interface.
The panel includes a profile image followed by the user’s basic account details. The example profile displays the name Admin User, the role System Administrator, an email address, and a phone number.
Below these details, we add a Quick Links section containing shortcuts to frequently used account-management options, including Change Password, Security Settings, and Notifications.
This section provides a compact overview of the user’s account and makes important settings easier to access.
The main settings area begins with the Personal Information section.
We structure the form into two columns so that related fields can be displayed side by side. The first row contains First Name and Last Name, followed by a second row containing Email ID and Phone Number.
This arrangement keeps the form organized and compact while providing a consistent layout for the user’s personal and contact information.
Next, we extend the personal information form to include the user’s organizational details.
A Department field is added as a selection component, while Role is configured as an input field. These fields capture information about the user’s position within the organization and follow the two-column structure established earlier.
The next step is to add fields for additional user information.
The Location field spans the available content width, while the Bio field uses a Text Area component to provide sufficient space for a short description or additional information about the user.
These fields extend the profile beyond basic contact details while maintaining a clear and consistent form structure.
Once the required personal information fields are added, we refine their arrangement.
The name, contact, department, and role fields are organized into two-column rows, while Location and Bio use the full available width. This grouping creates a consistent visual hierarchy and makes the form easier to scan.
Below the Personal Information section, we create the Notification Settings area.
This section includes four notification preferences:
Each preference is represented by a checkbox, allowing users to independently enable or disable the corresponding option.
This establishes the interface for managing different categories of application notifications.
We then add the Security Settings section, which is intended to accommodate account security information and password-related controls.
The profile interface also includes quick links for Change Password and Security Settings, keeping these account-management functions accessible from the profile page.
The final form section captures additional business-related information associated with the profile.
We add fields for GST Number, Bank Name, Account Number, and IFSC Code. These fields are arranged in pairs to maintain the two-column structure used throughout the form.
This completes the main profile interface, bringing together personal details, organizational information, notification preferences, security settings, and business information within a single screen.
We conclude the UI-building portion by reviewing the complete User Profile page.
The interface now contains the profile header, user information panel, personal information form, notification preferences, security settings, and additional business information.
The layout maintains a consistent relationship between the application navigation, profile summary, and main settings area, providing the foundation for the logic configuration that follows.
With the User Profile interface in place, we move to the Logic Builder to configure the logic required to load the logged-in user’s information into the profile page.
The workflow retrieves the stored user information, extracts the required properties, and uses those values to populate the corresponding profile components. It also retrieves the stored authentication token to prepare the authorization value used by the application.
We begin by configuring the loginData variable using the Get from Local Storage block.
The storage key is set to UserData, which retrieves the user information stored when the user logged into the application.
The returned information is saved in the variable so that it can be processed and its individual properties accessed throughout the remaining workflow.
Next, we retrieve the authentication token from session storage.
Using the Get from Session Storage block, we provide the key jwt-token and store the retrieved value in the Usertoken variable.
The token is then combined with the Bearer prefix to prepare the authorization value used by the application. This makes the stored authentication information available to the logic flow.
After retrieving the stored information, we check whether the loginData variable contains a value.
When user data is available, we use the Parse JSON from String block to convert the stored JSON string into a structured object. The parsed result is saved in the ParseloginData variable.
This step makes it possible to access individual properties from the user’s stored profile information.
Once the JSON data has been parsed, we use the Get Property of block to retrieve the individual profile values.
The workflow extracts the following properties:
first_name, stored in the firstName variable.last_name, stored in the lastname variable.email, stored in the email variable.userrole, stored in the role variable.These variables hold the extracted information and provide the values required to populate the corresponding User Profile components.
Next, we connect the extracted first name to the First Name input component.
Using the Component Instance block, we reference the First Name field. We then use the Set Property block, select its value property, and assign the firstName variable.
This automatically populates the field with the first name retrieved from the logged-in user’s stored profile information.
The field can also be disabled after the value is populated if it is intended to remain read-only.
We follow the same component-based approach to populate the Email field.
The Email input component is referenced through the Component Instance block, and its value property is set using the email variable.
This ensures that the stored email address is displayed automatically when the page loads. The Email field can then be disabled to keep the value controlled by the user’s account information.
The same approach is used to connect the remaining extracted user information to the appropriate interface components.
The lastname and role variables are assigned to their corresponding components using the Component Instance and Set Property blocks. For each component, we select the appropriate property, such as value, and provide the corresponding variable.
This establishes the connection between the information stored in the application and the profile interface.
We then configure the role or selection-based component available on the User Profile screen.
The corresponding input or select component is selected from the component tree, and its available properties are configured to use the relevant user information.
The role variable, populated from the userrole property of ParseloginData, is used to reflect the role associated with the logged-in user.
Once the component mappings are complete, we review the entire workflow.
The logic first retrieves the user’s information from local storage and obtains the authentication token from session storage. When user data is available, the JSON string is parsed into a structured object, and the required properties are extracted into individual variables.
These variables are then connected to the corresponding User Profile components using the Component Instance and Set Property blocks.
This approach allows the profile interface to display the logged-in user’s stored information rather than relying on manually entered example values.
Finally, we preview the User Profile page to verify the configured behavior.
We review the profile fields and confirm that the available user information is populated from the stored data. We also check that fields configured as read-only remain disabled and that the rest of the profile interface is available for further configuration.
This completes the User Profile logic configuration demonstrated in the training session.
By following this training, you will learn how to:
By the end of this session, you will have built the main structure of the User Profile screen and configured the core logic required to populate its fields using the logged-in user’s stored information.
The workflow demonstrates how local storage, session storage, JSON parsing, variables, component instances, and property updates work together to connect application data with the user interface.
This provides the foundation for further development of account-management functionality within the Smart Vendor & Procurement System using redSling Builder.