Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Frontend Assignment Use React JS for the Assignment Design: Display state: State based…

  1. User

    Frontend Assignment

    Use React JS for the Assignment

    Design:

    Display state:

    [image: Untitled] open

    State based on display. - Grouping by user is selected.

    [image: Untitled] open

    Grouping by priority is selected.

    [image: Untitled] open

    Card:

    [image: Untitled] open

    Api : https://api.quicksell.co/v1/internal/frontend-assignment

    You are required to create an interactive Kanban board application using React JS that interacts with the provided API from https://api.quicksell.co/v1/internal/frontend-assignment

    When a user clicks the "display" button and selects a grouping option, the Kanban board should dynamically adjust to reflect the user's choice.

    The application should offer three distinct ways to group the data:

    1. By Status: Group tickets based on their current status.
    2. By User: Arrange tickets according to the assigned user.
    3. By Priority: Group tickets based on their priority level.

    Users should also be able to sort the displayed tickets in two ways:

    1. Priority: Arrange tickets in descending order of priority.
    2. Title: Sort tickets in ascending order based on their title.

    The Kanban board should be responsive and visually appealing, with a design similar to the provided screenshots.

    The priority levels for the tickets are as follows:

    • Urgent (Priority level 4)
    • High (Priority level 3)
    • Medium (Priority level 2)
    • Low (Priority level 1)
    • No priority (Priority level 0)

    Priority levels: (This values you will receive in the api)

    4 - Urgent

    3 - High

    2 - Medium

    1 - Low

    0 - No priority

    Additionally, the application should save the user's view state even after page reload.

    Assets

    Untitled

    Note:

    1. Don’t use css library like Bootstrap, Tailwind, Vite, Material UI, Charka…etc
    2. Don’t use NextJs or similar framework. Code in pure ReactJS
    3. Write Pure CSS Code only. No library for css (bootstrap,..etc). Styled JSX can be used though

    Evaluation Criteria

    Your work will be evaluated based on the following criteria:

    UI Should Look exactly same as screenshot.

    1. Functionality: The application should effectively fetch data from the provided API and allow users to group and sort tickets based on the given options.
    2. Visual Design: The UI should match the provided design, including the layout, card design, and overall aesthetics.
    3. Business Logic Optimisation
    4. Component Structuring: Components should be appropriately structured, promoting reusability and maintainability.

    THe https://api.quicksell.co/v1/internal/frontend-assignment APi response on browser is - { "tickets": [ { "id": "CAM-1", "title": "Update User Profile Page UI", "tag": [ "Feature request" ], "userId": "usr-1", "status": "Todo", "priority": 4 }, { "id": "CAM-2", "title": "Add Multi-Language Support - Enable multi-language support within the application.", "tag": [ "Feature Request" ], "userId": "usr-2", "status": "In progress", "priority": 3 }, { "id": "CAM-3", "title": "Optimize Database Queries for Performance", "tag": [ "Feature Request" ], "userId": "usr-2", "status": "In progress", "priority": 1 }, { "id": "CAM-4", "title": "Implement Email Notification System", "tag": [ "Feature Request" ], "userId": "usr-1", "status": "In progress", "priority": 3 }, { "id": "CAM-5", "title": "Enhance Search Functionality", "tag": [ "Feature Request" ], "userId": "usr-5", "status": "In progress", "priority": 0 }, { "id": "CAM-6", "title": "Third-Party Payment Gateway", "tag": [ "Feature Request" ], "userId": "usr-2", "status": "Todo", "priority": 1 }, { "id": "CAM-7", "title": "Create Onboarding Tutorial for New Users", "tag": [ "Feature Request" ], "userId": "usr-1", "status": "Backlog", "priority": 2 }, { "id": "CAM-8", "title": "Implement Role-Based Access Control (RBAC)", "tag": [ "Feature Request" ], "userId": "usr-3", "status": "In progress", "priority": 3 }, { "id": "CAM-9", "title": "Upgrade Server Infrastructure", "tag": [ "Feature Request" ], "userId": "usr-5", "status": "Todo", "priority": 2 }, { "id": "CAM-10", "title": "Conduct Security Vulnerability Assessment", "tag": [ "Feature Request" ], "userId": "usr-4", "status": "Backlog", "priority": 1 } ], "users": [ { "id": "usr-1", "name": "Anoop sharma", "available": false }, { "id": "usr-2", "name": "Yogesh", "available": true }, { "id": "usr-3", "name": "Shankar Kumar", "available": true }, { "id": "usr-4", "name": "Ramesh", "available": true }, { "id": "usr-5", "name": "Suresh", "available": true } ] }

  2. Assistant

    Sure! I can guide you through building an interactive Kanban board application using React JS based on the provided assignment requirements. We'll cover the following steps:

    1. Project Setup
    2. Fetching Data from API
    3. State Management
    4. Grouping and Sorting Functionality
    5. Persisting View State
    6. Component Structure
    7. Styling with Pure CSS
    8. Final Touches and Optimization

    Let's dive into each step in detail.


    1. Project Setup

    First, set up your React project without using any CSS libraries or frameworks.

    Initialize the Project

    Use Create React App to set up the project:

    npx create-react-app kanban-board
    cd kanban-board
    

    Since the assignment specifies not to use frameworks like Vite or libraries like Tailwind, Create React App is suitable.

    Project Structure

    Organize your project structure for maintainability:

    kanban-board/
    ├── public/
    ├── src/
    │   ├── components/
    │   │   ├── Header/
    │   │   ├── KanbanBoard/
    │   │   ├── TicketCard/
    │   │   ├── GroupingOptions/
    │   │   ├── SortingOptions/
    │   ├── styles/
    │   ├── App.js
    │   ├── index.js
    │   └── ...
    ├── package.json
    └── ...
    

    2. Fetching Data from API

    We need to fetch data from the provided API: https://api.quicksell.co/v1/internal/frontend-assignment.

    Using useEffect and fetch

    We'll use React's useEffect hook to fetch data when the component mounts.

    // src/App.js
    import React, { useEffect, useState } from 'react';
    import KanbanBoard from './components/KanbanBoard/KanbanBoard';
    
    function App() {
      const [tickets, setTickets] = useState([]);
      const [users, setUsers] = useState([]);
      const [loading, setLoading] = useState(true);
    
      useEffect(() => {
        fetch('https://api.quicksell.co/v1/internal/frontend-assignment')
          .then((response) => response.json())
          .then((data) => {
            setTickets(data.tickets);
            setUsers(data.users);
            setLoading(false);
          })
          .catch((error) => {
            console.error('Error fetching data:', error);
            setLoading(false);
          });
      }, []);
    
      if (loading) {
        return <div>Loading...</div>;
      }
    
      return <KanbanBoard tickets={tickets} users={users} />;
    }
    
    export default App;
    

    3. State Management

    We'll manage the following states:

    • Tickets and Users: Fetched from the API.
    • Grouping Option: By Status, User, or Priority.
    • Sorting Option: By Priority or Title.
    • Persisted View State: Saved in localStorage.

    Managing Grouping and Sorting

    Create state variables for grouping and sorting options.

    // src/components/KanbanBoard/KanbanBoard.js
    import React, { useEffect, useState } from 'react';
    import GroupingOptions from '../GroupingOptions/GroupingOptions';
    import SortingOptions from '../SortingOptions/SortingOptions';
    import TicketCard from '../TicketCard/TicketCard';
    import './KanbanBoard.css';
    
    const KanbanBoard = ({ tickets, users }) => {
      const [groupBy, setGroupBy] = useState('status'); // default grouping
      const [sortBy, setSortBy] = useState('priority'); // default sorting
      const [groupedTickets, setGroupedTickets] = useState({});
    
      // Load view state from localStorage
      useEffect(() => {
        const savedGroupBy = localStorage.getItem('groupBy');
        const savedSortBy = localStorage.getItem('sortBy');
        if (savedGroupBy) setGroupBy(savedGroupBy);
        if (savedSortBy) setSortBy(savedSortBy);
      }, []);
    
      // Save view state to localStorage
      useEffect(() => {
        localStorage.setItem('groupBy', groupBy);
        localStorage.setItem('sortBy', sortBy);
      }, [groupBy, sortBy]);
    
      // Group and sort tickets whenever tickets, groupBy, or sortBy changes
      useEffect(() => {
        let grouped = {};
    
        // Grouping logic
        tickets.forEach((ticket) => {
          let key = '';
          if (groupBy === 'status') {
            key = ticket.status;
          } else if (groupBy === 'user') {
            const user = users.find((u) => u.id === ticket.userId);
            key = user ? user.name : 'Unknown';
          } else if (groupBy === 'priority') {
            key = getPriorityLabel(ticket.priority);
          }
    
          if (!grouped[key]) {
            grouped[key] = [];
          }
    
          grouped[key].push(ticket);
        });
    
        // Sorting logic within each group
        Object.keys(grouped).forEach((group) => {
          grouped[group].sort((a, b) => {
            if (sortBy === 'priority') {
              return b.priority - a.priority; // Descending
            } else if (sortBy === 'title') {
              return a.title.localeCompare(b.title); // Ascending
            }
            return 0;
          });
        });
    
        setGroupedTickets(grouped);
      }, [tickets, groupBy, sortBy, users]);
    
      const getPriorityLabel = (priority) => {
        switch (priority) {
          case 4:
            return 'Urgent';
          case 3:
            return 'High';
          case 2:
            return 'Medium';
          case 1:
            return 'Low';
          case 0:
          default:
            return 'No priority';
        }
      };
    
      return (
        <div className="kanban-container">
          <div className="controls">
            <GroupingOptions groupBy={groupBy} setGroupBy={setGroupBy} />
            <SortingOptions sortBy={sortBy} setSortBy={setSortBy} />
          </div>
          <div className="kanban-board">
            {Object.keys(groupedTickets).map((group) => (
              <div key={group} className="kanban-column">
                <h2>{group}</h2>
                {groupedTickets[group].map((ticket) => (
                  <TicketCard key={ticket.id} ticket={ticket} users={users} />
                ))}
              </div>
            ))}
          </div>
        </div>
      );
    };
    
    export default KanbanBoard;
    

    4. Grouping and Sorting Functionality

    Grouping Options Component

    Create a component to allow users to select grouping options.

    // src/components/GroupingOptions/GroupingOptions.js
    import React from 'react';
    import './GroupingOptions.css';
    
    const GroupingOptions = ({ groupBy, setGroupBy }) => {
      return (
        <div className="grouping-options">
          <label>Group By:</label>
          <select value={groupBy} onChange={(e) => setGroupBy(e.target.value)}>
            <option value="status">Status</option>
            <option value="user">User</option>
            <option value="priority">Priority</option>
          </select>
        </div>
      );
    };
    
    export default GroupingOptions;
    

    Sorting Options Component

    Create a component to allow users to select sorting options.

    // src/components/SortingOptions/SortingOptions.js
    import React from 'react';
    import './SortingOptions.css';
    
    const SortingOptions = ({ sortBy, setSortBy }) => {
      return (
        <div className="sorting-options">
          <label>Sort By:</label>
          <select value={sortBy} onChange={(e) => setSortBy(e.target.value)}>
            <option value="priority">Priority</option>
            <option value="title">Title</option>
          </select>
        </div>
      );
    };
    
    export default SortingOptions;
    

    5. Persisting View State

    We've already implemented persisting view state using localStorage in the KanbanBoard component's useEffect hooks.


    6. Component Structure

    TicketCard Component

    Each ticket will be displayed as a card. This component displays ticket details.

    // src/components/TicketCard/TicketCard.js
    import React from 'react';
    import './TicketCard.css';
    
    const TicketCard = ({ ticket, users }) => {
      const user = users.find((u) => u.id === ticket.userId);
    
      const getPriorityLabel = (priority) => {
        switch (priority) {
          case 4:
            return 'Urgent';
          case 3:
            return 'High';
          case 2:
            return 'Medium';
          case 1:
            return 'Low';
          case 0:
          default:
            return 'No priority';
        }
      };
    
      return (
        <div className="ticket-card">
          <div className="ticket-header">
            <span className={`priority ${getPriorityLabel(ticket.priority).toLowerCase().replace(' ', '-')}`}>
              {getPriorityLabel(ticket.priority)}
            </span>
            <span className="ticket-id">{ticket.id}</span>
          </div>
          <div className="ticket-title">{ticket.title}</div>
          <div className="ticket-tags">
            {ticket.tag.map((tag, index) => (
              <span key={index} className="ticket-tag">
                {tag}
              </span>
            ))}
          </div>
          <div className="ticket-user">
            Assigned to: {user ? user.name : 'Unknown'}
          </div>
        </div>
      );
    };
    
    export default TicketCard;
    

    7. Styling with Pure CSS

    Since the assignment restricts using CSS libraries, we'll use pure CSS for styling. Below are example styles for the components. Adjust these according to your design requirements.

    KanbanBoard Styles

    /* src/components/KanbanBoard/KanbanBoard.css */
    .kanban-container {
      padding: 20px;
      font-family: Arial, sans-serif;
    }
    
    .controls {
      display: flex;
      justify-content: space-between;
      margin-bottom: 20px;
    }
    
    .kanban-board {
      display: flex;
      gap: 20px;
      overflow-x: auto;
    }
    
    .kanban-column {
      background-color: #f4f5f7;
      border-radius: 5px;
      padding: 10px;
      min-width: 250px;
    }
    
    .kanban-column h2 {
      text-align: center;
      margin-bottom: 10px;
    }
    

    GroupingOptions Styles

    /* src/components/GroupingOptions/GroupingOptions.css */
    .grouping-options {
      display: flex;
      align-items: center;
      gap: 10px;
    }
    
    .grouping-options label {
      font-weight: bold;
    }
    

    SortingOptions Styles

    /* src/components/SortingOptions/SortingOptions.css */
    .sorting-options {
      display: flex;
      align-items: center;
      gap: 10px;
    }
    
    .sorting-options label {
      font-weight: bold;
    }
    

    TicketCard Styles

    /* src/components/TicketCard/TicketCard.css */
    .ticket-card {
      background-color: white;
      border-radius: 5px;
      padding: 10px;
      margin-bottom: 10px;
      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
    }
    
    .ticket-header {
      display: flex;
      justify-content: space-between;
      align-items: center;
    }
    
    .priority {
      padding: 2px 6px;
      border-radius: 3px;
      font-size: 12px;
      color: white;
    }
    
    .priority.urgent {
      background-color: red;
    }
    
    .priority.high {
      background-color: orange;
    }
    
    .priority.medium {
      background-color: yellow;
      color: black;
    }
    
    .priority.low {
      background-color: green;
    }
    
    .priority.no-priority {
      background-color: grey;
    }
    
    .ticket-id {
      font-size: 12px;
      color: #555;
    }
    
    .ticket-title {
      margin: 10px 0;
      font-weight: bold;
    }
    
    .ticket-tags {
      margin-bottom: 10px;
    }
    
    .ticket-tag {
      background-color: #e0e0e0;
      border-radius: 3px;
      padding: 2px 4px;
      font-size: 10px;
      margin-right: 5px;
    }
    
    .ticket-user {
      font-size: 12px;
      color: #555;
    }
    

    Responsive Design

    Ensure the Kanban board is responsive. The overflow-x: auto; on the .kanban-board allows horizontal scrolling on smaller screens.


    8. Final Touches and Optimization

    Handling Edge Cases

    • Missing User Data: Ensure that if a user is missing, the application gracefully displays 'Unknown'.
    • Empty Tickets: Handle scenarios where there are no tickets to display for a particular group.

    Performance Optimization

    • Memoization: Use React.memo or useMemo to prevent unnecessary re-renders.
    • Efficient Sorting and Grouping: Optimize the grouping and sorting logic to handle large datasets efficiently.

    Example: Using React.memo for TicketCard

    // src/components/TicketCard/TicketCard.js
    import React from 'react';
    import './TicketCard.css';
    
    const TicketCard = React.memo(({ ticket, users }) => {
      const user = users.find((u) => u.id === ticket.userId);
    
      const getPriorityLabel = (priority) => {
        switch (priority) {
          case 4:
            return 'Urgent';
          case 3:
            return 'High';
          case 2:
            return 'Medium';
          case 1:
            return 'Low';
          case 0:
          default:
            return 'No priority';
        }
      };
    
      return (
        <div className="ticket-card">
          <div className="ticket-header">
            <span className={`priority ${getPriorityLabel(ticket.priority).toLowerCase().replace(' ', '-')}`}>
              {getPriorityLabel(ticket.priority)}
            </span>
            <span className="ticket-id">{ticket.id}</span>
          </div>
          <div className="ticket-title">{ticket.title}</div>
          <div className="ticket-tags">
            {ticket.tag.map((tag, index) => (
              <span key={index} className="ticket-tag">
                {tag}
              </span>
            ))}
          </div>
          <div className="ticket-user">
            Assigned to: {user ? user.name : 'Unknown'}
          </div>
        </div>
      );
    });
    
    export default TicketCard;
    

    Full Example Code

    Here's the complete code for each component.

    src/App.js

    import React, { useEffect, useState } from 'react';
    import KanbanBoard from './components/KanbanBoard/KanbanBoard';
    
    function App() {
      const [tickets, setTickets] = useState([]);
      const [users, setUsers] = useState([]);
      const [loading, setLoading] = useState(true);
    
      useEffect(() => {
        fetch('https://api.quicksell.co/v1/internal/frontend-assignment')
          .then((response) => response.json())
          .then((data) => {
            setTickets(data.tickets);
            setUsers(data.users);
            setLoading(false);
          })
          .catch((error) => {
            console.error('Error fetching data:', error);
            setLoading(false);
          });
      }, []);
    
      if (loading) {
        return <div>Loading...</div>;
      }
    
      return <KanbanBoard tickets={tickets} users={users} />;
    }
    
    export default App;
    

    src/components/KanbanBoard/KanbanBoard.js

    import React, { useEffect, useState } from 'react';
    import GroupingOptions from '../GroupingOptions/GroupingOptions';
    import SortingOptions from '../SortingOptions/SortingOptions';
    import TicketCard from '../TicketCard/TicketCard';
    import './KanbanBoard.css';
    
    const KanbanBoard = ({ tickets, users }) => {
      const [groupBy, setGroupBy] = useState('status'); // default grouping
      const [sortBy, setSortBy] = useState('priority'); // default sorting
      const [groupedTickets, setGroupedTickets] = useState({});
    
      // Load view state from localStorage
      useEffect(() => {
        const savedGroupBy = localStorage.getItem('groupBy');
        const savedSortBy = localStorage.getItem('sortBy');
        if (savedGroupBy) setGroupBy(savedGroupBy);
        if (savedSortBy) setSortBy(savedSortBy);
      }, []);
    
      // Save view state to localStorage
      useEffect(() => {
        localStorage.setItem('groupBy', groupBy);
        localStorage.setItem('sortBy', sortBy);
      }, [groupBy, sortBy]);
    
      // Group and sort tickets whenever tickets, groupBy, or sortBy changes
      useEffect(() => {
        let grouped = {};
    
        // Grouping logic
        tickets.forEach((ticket) => {
          let key = '';
          if (groupBy === 'status') {
            key = ticket.status;
          } else if (groupBy === 'user') {
            const user = users.find((u) => u.id === ticket.userId);
            key = user ? user.name : 'Unknown';
          } else if (groupBy === 'priority') {
            key = getPriorityLabel(ticket.priority);
          }
    
          if (!grouped[key]) {
            grouped[key] = [];
          }
    
          grouped[key].push(ticket);
        });
    
        // Sorting logic within each group
        Object.keys(grouped).forEach((group) => {
          grouped[group].sort((a, b) => {
            if (sortBy === 'priority') {
              return b.priority - a.priority; // Descending
            } else if (sortBy === 'title') {
              return a.title.localeCompare(b.title); // Ascending
            }
            return 0;
          });
        });
    
        setGroupedTickets(grouped);
      }, [tickets, groupBy, sortBy, users]);
    
      const getPriorityLabel = (priority) => {
        switch (priority) {
          case 4:
            return 'Urgent';
          case 3:
            return 'High';
          case 2:
            return 'Medium';
          case 1:
            return 'Low';
          case 0:
          default:
            return 'No priority';
        }
      };
    
      return (
        <div className="kanban-container">
          <div className="controls">
            <GroupingOptions groupBy={groupBy} setGroupBy={setGroupBy} />
            <SortingOptions sortBy={sortBy} setSortBy={setSortBy} />
          </div>
          <div className="kanban-board">
            {Object.keys(groupedTickets).map((group) => (
              <div key={group} className="kanban-column">
                <h2>{group}</h2>
                {groupedTickets[group].map((ticket) => (
                  <TicketCard key={ticket.id} ticket={ticket} users={users} />
                ))}
              </div>
            ))}
          </div>
        </div>
      );
    };
    
    export default KanbanBoard;
    

    src/components/GroupingOptions/GroupingOptions.js

    import React from 'react';
    import './GroupingOptions.css';
    
    const GroupingOptions = ({ groupBy, setGroupBy }) => {
      return (
        <div className="grouping-options">
          <label>Group By:</label>
          <select value={groupBy} onChange={(e) => setGroupBy(e.target.value)}>
            <option value="status">Status</option>
            <option value="user">User</option>
            <option value="priority">Priority</option>
          </select>
        </div>
      );
    };
    
    export default GroupingOptions;
    

    src/components/SortingOptions/SortingOptions.js

    import React from 'react';
    import './SortingOptions.css';
    
    const SortingOptions = ({ sortBy, setSortBy }) => {
      return (
        <div className="sorting-options">
          <label>Sort By:</label>
          <select value={sortBy} onChange={(e) => setSortBy(e.target.value)}>
            <option value="priority">Priority</option>
            <option value="title">Title</option>
          </select>
        </div>
      );
    };
    
    export default SortingOptions;
    

    src/components/TicketCard/TicketCard.js

    import React from 'react';
    import './TicketCard.css';
    
    const TicketCard = React.memo(({ ticket, users }) => {
      const user = users.find((u) => u.id === ticket.userId);
    
      const getPriorityLabel = (priority) => {
        switch (priority) {
          case 4:
            return 'Urgent';
          case 3:
            return 'High';
          case 2:
            return 'Medium';
          case 1:
            return 'Low';
          case 0:
          default:
            return 'No priority';
        }
      };
    
      return (
        <div className="ticket-card">
          <div className="ticket-header">
            <span className={`priority ${getPriorityLabel(ticket.priority).toLowerCase().replace(' ', '-')}`}>
              {getPriorityLabel(ticket.priority)}
            </span>
            <span className="ticket-id">{ticket.id}</span>
          </div>
          <div className="ticket-title">{ticket.title}</div>
          <div className="ticket-tags">
            {ticket.tag.map((tag, index) => (
              <span key={index} className="ticket-tag">
                {tag}
              </span>
            ))}
          </div>
          <div className="ticket-user">
            Assigned to: {user ? user.name : 'Unknown'}
          </div>
        </div>
      );
    });
    
    export default TicketCard;
    

    Testing the Application

    After setting up all components and styles, run the application to test its functionality.

    npm start
    

    Navigate to http://localhost:3000 to view the Kanban board. Test the grouping and sorting functionalities, and verify that the view state persists after refreshing the page.


    Additional Recommendations

    • Accessibility: Ensure that the application is accessible. Use semantic HTML elements and ARIA attributes where necessary.
    • Error Handling: Implement better error handling for API failures, such as displaying error messages to the user.
    • Loading States: Enhance the loading experience with spinners or skeleton screens.
    • Unit Testing: Write unit tests for components to ensure reliability.
    • Code Quality: Use linters like ESLint and formatters like Prettier to maintain code quality.

    Conclusion

    By following the above steps, you can create an interactive, responsive Kanban board application in React JS that meets the assignment's requirements. Remember to focus on component reusability, maintainability, and optimizing business logic for the best results. Good luck with your assignment!