class Company { constructor(departments){ let roomCount = 0 this.departments = departments.map(d=> new Department(d)) departments.forEach((d,i)=>{ if(i != 0){ const parent = this.departments.find(e => e.name == d.parent) this.departments[i].parent = (parent)? parent : this.departments[0] } this.departments[i].id = i }) //Create company.employees this.employees = this.departments.reduce((acc,curr)=>{ return acc.concat(curr.employees) },[]) //Set employee IDs this.employees.forEach((e,i)=>{e.id = i}) //Set manager and team for department heads let csuite = this.departments.find(d=>d.level == 0) let boss = csuite.head let operations = (boss.reports.length > 0) ? boss.reports[0] : boss let team = [] this.departments.forEach(d=>{ if(d.level != 0){ operations.reports.push(d.head) d.head.manager = operations team.push(d.head) } }) team.forEach(e=>{e.team = team.filter(t=>t.id != e.id)}) // Create Offices + Cubicles roomCount = this.createDesks(roomCount) // Create Meetings this.meetingRooms = [] roomCount = this.createMeetingRooms(roomCount) this.meetings = [] this.scheduleMeetings() // Connection scoring - manager/reports/team // TODO: scoring based on location to desk this.employees.forEach(e=>{ if(e.team) e.connect(e.team.map(t=>t.id)) if(e.reports) e.connect(e.reports.map(t=>t.id)) if(e.manager) e.connect(e.manager.id) }) // Connection scoring - shared meetings this.meetings.forEach(m=>{ m.attendees.forEach(a=>{ a.connect(m.attendees.filter(aa=>aa.id != a.id).map(aa=>aa.id)) }) }) } //---------------------------------------------------------- createMeetingRooms(roomCount){ let roomAmount = Math.round(this.employees.length / Math.floor(randBM(...config.employeeToRoom))) let id = roomCount let rooms = new Array(roomAmount).fill(true) rooms = rooms.map((d,i)=>{ let s = Math.floor(Math.random() *4) + 6 return new MeetingRoom({id:id++,size: s + s % 2}) }) this.meetingRooms = rooms return id } //---------------------------------------------------------- createDesks(roomCount){ let offices = this.employees.filter(e=>e.level <= config.officeLevel[config.officeLevel.length - 1]) let cubicles = this.employees.filter(e=>e.level > config.officeLevel[config.officeLevel.length - 1]) let id = roomCount offices = offices.map((e,i)=>{ let size let occupancy for(let i = 0; i< config.officeLevel.length; i++){ if(e.level <= config.officeLevel[i]){ size = config.officeSize[i] occupancy = config.officeOccupancy[i] break } } let office = new Office({id:id++, name: e.name + "'s Office", employee: e, size, occupancy}) e.desk = office return office }) cubicles = cubicles.map((e,i)=>{ let cube = new Cubicle({id:id++, name: e.name + "'s Desk", employee: e}) e.desk = cube return cube }) this.cubicles = cubicles this.offices = offices return id } //---------------------------------------------------------- scheduleMeetings(){ let employees = this.employees let id = 0 let attempt = 0 while(employees.length > 0){ // START LOOP -------------------- attempt ++ // Order by level, then availability employees.sort((a,b) => a.level - b.level || b.availability - a.availability) // Remove employees who are overbooked employees = employees.filter(e=>e.availability >= e.utilization) //remove host from the stack const host = employees.shift() const count = Math.ceil(Math.random() * config.meetingAttendees) // Number of Attendees const duration = Math.floor(randBM(...config.meetingLength)) // Meeting Length let attendees = employees .filter(e=>Math.abs(e.level - host.level) <= config.meetingLevelRange) // filter employees within X levels of host .sort((a,b)=>Math.random() * 2 - 1) // randomly order the participants .slice(0,count) // take first #count as the attendees let start = attendees.sort((a,b)=>b.schedule.start - a.schedule.start) // order attendees by start time //No attendees if(start.length == 0){ break } //First available meeting is from the employee's start time start = start[0].schedule.start + 1 let hostSchedule = host.schedule let meetingStart = 0 let found = 0 for(let i = 0; i < hostSchedule.length; i++){ //Find first open available spot from the host if(hostSchedule[i] != 'open'){ meetingStart = i + 1 found = 0 continue } //every attendee has a slot open if( attendees.every(a=>a.schedule[i]=='open') ){ found++ } else { meetingStart = i + 1 found = 0 } //We found available slot across all schedules if (found == duration) break } //If found slots is less than the meeting length if(found < duration){ //attempts exceed the number of employees, restart excluding host if(attempt >= employees.length){ attempt = 0 continue } else { //add host back to the pile and restart employees.unshift(host) continue } } if(found == duration){ attendees.unshift(host) const meeting = { id: id++, type: 'meeting', time: meetingStart, duration: duration, host, attendees } //!--- // TODO: Map levels to office sizes/capacity let rankingEmployee = meeting.attendees.sort((a,b)=>a.level - b.level)[0] let room = this.meetingRooms.find(r=>r.schedule.check(meetingStart,duration)) if(room){ meeting.location = room room.schedule.add(meeting) room.schedule.meetings.push(meeting) } else if(rankingEmployee.level <= config.officeLevel[0] && attendees.length <= config.officeOccupancy[0]){ //meet in a big office meeting.location = rankingEmployee.desk } else if(rankingEmployee.level <= config.officeLevel[1] && attendees.length <= config.officeOccupancy[1]){ //meet in a little office meeting.location = rankingEmployee.desk } else if(attendees.length == 2){ //meet at desk meeting.location = host.desk } if(meeting.location){ attendees.forEach(a=>{ a.schedule.add(meeting) a.schedule.meetings.push(meeting) }) this.meetings.push(meeting) } employees.unshift(host) } } } }