Task - TypeScript - Interfaces, Arrow functions, Array methods (push, findIndex), and Class concepts - Event Management System

[akash-coded]

You have been asked to develop an event management system that handles registration, attendance, and feedback for various events. The system should allow users to register for events, mark their attendance, and provide feedback for attended events.

Create an interface MyEvent with the following specifications:

Properties:

• id: number - A unique identifier for the event.
• name: string - The name of the event.
• date: string - The date of the event.

Methods:

• register(user: User): void - A method that registers a user for the event.
• attend(user: User): void - A method that marks a user's attendance for the event.
• provideFeedback(user: User, feedback: string): void - A method that allows a user to provide feedback for the event.

Create a class User with the following properties:

Properties:

• id: number - A unique identifier for the user.
• name: string - The name of the user.

Implement the MyEvent interface in a class EventManager and add the following methods:

Methods:

• getRegistrants(): User[] - A method that returns an array of registered users for the event.
• getAttendees(): User[] - A method that returns an array of users who attended the event.
• getFeedback(): { user: User, feedback: string }[] - A method that returns an array of feedback objects containing the user and their feedback.

Make use of arrow functions and array methods push and findIndex in the implementation.

[SathyaGanes]

CODE

interface Event {
  id: number;
  name: string;
  date: string;
  register(user: User): void;
  attend(user: User): void;
  provideFeedback(user: User, feedback: string): void;
}

interface User {
  id: number;
  name: string;
}

class EventImpl implements Event {
  private attendees: User[] = [];
  private feedback: Map<User, string> = new Map();

  constructor(public id: number, public name: string, public date: string) {}

  register(user: User): void {
    this.attendees.push(user);
  }

  attend(user: User): void {
    if (this.attendees.includes(user)) {
      console.log(`${user.name} is already marked as attended for event ${this.name}.`);
    } else {
      this.attendees.push(user);
      console.log(`${user.name} attended event ${this.name}.`);
    }
  }

  provideFeedback(user: User, feedback: string): void {
    if (!this.attendees.includes(user)) {
      console.log(`${user.name} did not attend event ${this.name} and cannot provide feedback.`);
    } else {
      this.feedback.set(user, feedback);
      console.log(`${user.name} provided feedback for event ${this.name}: ${feedback}`);
    }
  }
}

// Example usage
const event1: Event = new EventImpl(1, "Conference", "2023-05-01");
const user1: User = { id: 1, name: "Alice" };
const user2: User = { id: 2, name: "Bob" };

event1.register(user1);
event1.register(user2);
event1.attend(user1); // prints "Alice attended event Conference."
event1.attend(user2); // prints "Bob attended event Conference."
event1.attend(user1); // prints "Alice is already marked as attended for event Conference."
event1.provideFeedback(user1, "Great event!"); // prints "Alice provided feedback for event Conference: Great event!"
event1.provideFeedback(user2, "Could have been better."); // prints "Bob provided feedback for event Conference: Could have been better."
event1.provideFeedback({ id: 3, name: "Charlie" }, "Awesome!"); // prints "Charlie did not attend event Conference and cannot provide feedback."

[SathyaGanes]

CODE

class User {
  constructor(public id: number, public name: string) {}
}

interface Event {
  id: number;
  name: string;
  date: string;
  register(user: User): void;
  attend(user: User): void;
  provideFeedback(user: User, feedback: string): void;
  getRegistrants(): User[];
  getAttendees(): User[];
  getFeedback(): { user: User; feedback: string }[];
}

class EventManager implements Event {
  private attendees: User[] = [];
  private feedback: { user: User; feedback: string }[] = [];

  constructor(public id: number, public name: string, public date: string) {}

  register = (user: User): void => {
    this.attendees.push(user);
  };

  attend = (user: User): void => {
    if (this.attendees.includes(user)) {
      console.log(`${user.name} is already marked as attended for event ${this.name}.`);
    } else {
      this.attendees.push(user);
      console.log(`${user.name} attended event ${this.name}.`);
    }
  };

  provideFeedback = (user: User, feedback: string): void => {
    if (!this.attendees.includes(user)) {
      console.log(`${user.name} did not attend event ${this.name} and cannot provide feedback.`);
    } else {
      this.feedback.push({ user, feedback });
      console.log(`${user.name} provided feedback for event ${this.name}: ${feedback}`);
    }
  };

  getRegistrants = (): User[] => {
    return [...this.attendees];
  };

  getAttendees = (): User[] => {
    return [...this.attendees];
  };

  getFeedback = (): { user: User; feedback: string }[] => {
    return [...this.feedback];
  };
}

// Example usage
const event1: Event = new EventManager(1, "Conference", "2023-05-01");
const user1: User = new User(1, "Alice");
const user2: User = new User(2, "Bob");
const user3: User = new User(3, "Charlie");

event1.register(user1);
event1.register(user2);
event1.attend(user1);
event1.provideFeedback(user1, "Great event!");
event1.attend(user2);
event1.provideFeedback(user2, "Could have been better.");

console.log("Registrants:", event1.getRegistrants()); // prints "[User { id: 1, name: 'Alice' }, User { id: 2, name: 'Bob' }]"
console.log("Attendees:", event1.getAttendees()); // prints "[User { id: 1, name: 'Alice' }, User { id: 2, name: 'Bob' }]"
console.log("Feedback:", event1.getFeedback()); // prints "[{ user: User { id: 1, name: 'Alice' }, feedback: 'Great event!' }, { user: User { id: 2, name: 'Bob' }, feedback: 'Could have been better.' }]"

[sam2elect]

CODE

interface Event {
    id: number;
    name: string;
    date: string;
    register(user: User): void;
    attend(user: User): void;
    provideFeedback(user: User, feedback: string): void;
  }
  
  class User {
    id: number;
    name: string;
    
    constructor(id: number, name: string) {
      this.id = id;
      this.name = name;
    }
  }
  
  class EventManager implements Event {
    id: number;
    name: string;
    date: string;
    registrants: User[] = [];
    attendees: User[] = [];
    feedbacks: { user: User, feedback: string }[] = [];
    
    constructor(id: number, name: string, date: string) {
      this.id = id;
      this.name = name;
      this.date = date;
    }
      bubbles: boolean;
      cancelBubble: boolean;
      cancelable: boolean;
      composed: boolean;
      currentTarget: EventTarget | null;
      defaultPrevented: boolean;
      eventPhase: number;
      isTrusted: boolean;
      returnValue: boolean;
      srcElement: EventTarget | null;
      target: EventTarget | null;
      timeStamp: number;
      type: string;
      composedPath(): EventTarget[] {
          throw new Error("Method not implemented.");
      }
      initEvent(type: string, bubbles?: boolean | undefined, cancelable?: boolean | undefined): void {
          throw new Error("Method not implemented.");
      }
      preventDefault(): void {
          throw new Error("Method not implemented.");
      }
      stopImmediatePropagation(): void {
          throw new Error("Method not implemented.");
      }
      stopPropagation(): void {
          throw new Error("Method not implemented.");
      }
      NONE: 0;
      CAPTURING_PHASE: 1;
      AT_TARGET: 2;
      BUBBLING_PHASE: 3;
    
    register(user: User): void {
      this.registrants.push(user);
    }
    
    attend(user: User): void {
      const index = this.registrants.findIndex(u => u.id === user.id);
      if (index !== -1) {
        this.attendees.push(user);
        this.registrants.splice(index, 1);
      }
    }
    
    provideFeedback(user: User, feedback: string): void {
      this.feedbacks.push({ user, feedback });
    }
    
    getRegistrants(): User[] {
      return this.registrants;
    }
    
    getAttendees(): User[] {
      return this.attendees;
    }
    
    getFeedback(): { user: User, feedback: string }[] {
      return this.feedbacks;
    }
  }
  

  const eventManager = new EventManager(1, 'My Event', '2023-05-01');

const user1 = new User(1, 'John');
const user2 = new User(2, 'Jane');

eventManager.register(user1);
eventManager.register(user2);

eventManager.attend(user1);

eventManager.provideFeedback(user1, 'Great event!');
eventManager.provideFeedback(user2, 'Could be better.');

console.log(eventManager.getRegistrants());
console.log(eventManager.getAttendees());
console.log(eventManager.getFeedback());

SCREENSHORT

[pujita789]

Code

interface Event {
id: number;
name: string;
date: string;
register(user: User): void;
attend(user: User): void;
provideFeedback(user: User, feedback: string): void;
}

class User {
id: number;
name: string;

constructor(id: number, name: string) {
  this.id = id;
  this.name = name;
}

}

class EventManager implements Event {
id: number;
name: string;
date: string;
registrants: User[] = [];
attendees: User[] = [];
feedbacks: { user: User, feedback: string }[] = [];

constructor(id: number, name: string, date: string) {
  this.id = id;
  this.name = name;
  this.date = date;
}
  bubbles: boolean;
  cancelBubble: boolean;
  cancelable: boolean;
  composed: boolean;
  currentTarget: EventTarget | null;
  defaultPrevented: boolean;
  eventPhase: number;
  isTrusted: boolean;
  returnValue: boolean;
  srcElement: EventTarget | null;
  target: EventTarget | null;
  timeStamp: number;
  type: string;
  composedPath(): EventTarget[] {
      throw new Error("Method not implemented.");
  }
  initEvent(type: string, bubbles?: boolean | undefined, cancelable?: boolean | undefined): void {
      throw new Error("Method not implemented.");
  }
  preventDefault(): void {
      throw new Error("Method not implemented.");
  }
  stopImmediatePropagation(): void {
      throw new Error("Method not implemented.");
  }
  stopPropagation(): void {
      throw new Error("Method not implemented.");
  }
  NONE: 0;
  CAPTURING_PHASE: 1;
  AT_TARGET: 2;
  BUBBLING_PHASE: 3;

register(user: User): void {
  this.registrants.push(user);
}

attend(user: User): void {
  const index = this.registrants.findIndex(u => u.id === user.id);
  if (index !== -1) {
    this.attendees.push(user);
    this.registrants.splice(index, 1);
  }
}

provideFeedback(user: User, feedback: string): void {
  this.feedbacks.push({ user, feedback });
}

getRegistrants(): User[] {
  return this.registrants;
}

getAttendees(): User[] {
  return this.attendees;
}

getFeedback(): { user: User, feedback: string }[] {
  return this.feedbacks;
}

}

const eventManager = new EventManager(1, 'My Event', '2023-05-01');

const user1 = new User(1, 'Pujita');
const user2 = new User(2, 'Chakraborty');

eventManager.register(user1);
eventManager.register(user2);

eventManager.attend(user1);

eventManager.provideFeedback(user1, 'Great event!');
eventManager.provideFeedback(user2, 'Could be better.');

console.log(eventManager.getRegistrants());
console.log(eventManager.getAttendees());
console.log(eventManager.getFeedback());

[saugatacr7]

interface Event {
id: number;
name: string;
date: string;
register(user: User): void;
attend(user: User): void;
provideFeedback(user: User, feedback: string): void;
}

class User {
id: number;
name: string;

constructor(id: number, name: string) {
  this.id = id;
  this.name = name;
}

}

class EventManager implements Event {
id: number;
name: string;
date: string;
registrants: User[] = [];
attendees: User[] = [];
feedbacks: { user: User, feedback: string }[] = [];

constructor(id: number, name: string, date: string) {
  this.id = id;
  this.name = name;
  this.date = date;
  
  register(user: User): void {

this.registrants.push(user);
}

attend(user: User): void {
const index = this.registrants.findIndex(u => u.id === user.id);
if (index !== -1) {
this.attendees.push(user);
this.registrants.splice(index, 1);
}
}

provideFeedback(user: User, feedback: string): void {
this.feedbacks.push({ user, feedback });
}

getRegistrants(): User[] {
return this.registrants;
}

getAttendees(): User[] {
return this.attendees;
}

getFeedback(): { user: User, feedback: string }[] {
return this.feedbacks;
}

[vk0027]

interface MyEvent {
id: number;
name: string;
date: string;
register(user: User): void;
attend(user: User): void;
provideFeedback(user: User, feedback: string): void;
}

class User {
id: number;
name: string;

constructor(id: number, name: string) {
this.id = id;
this.name = name;
}
}

class EventManager implements MyEvent {
id: number;
name: string;
date: string;
registrants: User[];
attendees: User[];
feedbacks: { user: User, feedback: string }[];

constructor(id: number, name: string, date: string) {
this.id = id;
this.name = name;
this.date = date;
this.registrants = [];
this.attendees = [];
this.feedbacks = [];
}

register(user: User): void {
const index = this.registrants.findIndex((u) => u.id === user.id);
if (index === -1) {
this.registrants.push(user);
} else {
console.log(${user.name} is already registered for the event.);
}
}

attend(user: User): void {
const index = this.attendees.findIndex((u) => u.id === user.id);
if (index === -1) {
this.attendees.push(user);
} else {
console.log(${user.name} has already attended the event.);
}
}

provideFeedback(user: User, feedback: string): void {
const index = this.feedbacks.findIndex((f) => f.user.id === user.id);
if (index === -1) {
this.feedbacks.push({ user, feedback });
} else {
this.feedbacks[index].feedback = feedback;
}
}

getRegistrants(): User[] {
return this.registrants;
}

getAttendees(): User[] {
return this.attendees;
}

getFeedback(): { user: User, feedback: string }[] {
return this.feedbacks;
}
}