1  import calculations from './calculations.js'
  2  
  3  let inAddressConnect, outAddressConnect, color, colors
  4  
  5  function aoActions(aos, ev) {
  6    switch (ev.type) {
  7      case "ao-inbound-connected":
  8        inAddressConnect = aos.some(a => {
  9          if (a.address === ev.address) {
 10            a.alias = ev.alias
 11            a.inboundSecret = ev.secret
 12            a.lastContact = Date.now()
 13            return true
 14          }
 15        })
 16        if (!inAddressConnect) {
 17          let newEv = {
 18            alias: ev.alias,
 19            address: ev.address,
 20            outboundSecret: false,
 21            inboundSecret: ev.secret,
 22            lastContact: Date.now(),
 23          }
 24          aos.push(newEv)
 25        }
 26        break
 27      case "ao-outbound-connected":
 28        outAddressConnect = aos.some(a => {
 29          if (a.address === ev.address) {
 30            a.outboundSecret = ev.secret
 31            a.lastContact = Date.now()
 32            return true
 33          }
 34        })
 35        if (!outAddressConnect) {
 36          let newEv = {
 37            address: ev.address,
 38            outboundSecret: ev.secret,
 39            inboundSecret: false,
 40            lastContact: Date.now(),
 41            alias: 'ao',
 42          }
 43          aos.push(newEv)
 44        }
 45        break
 46      case "ao-disconnected":
 47        aos.some((ao, i) => {
 48          if (ao.address === ev.address) {
 49            aos.splice(i, 1)
 50            return true
 51          }
 52        })
 53        break
 54    }
 55  }
 56  
 57  function cashActions(cash, ev) {
 58    switch (ev.type) {
 59      case "spot-updated":
 60        cash.spot = ev.spot
 61        break
 62      case "currency-switched":
 63        cash.currency = ev.currency
 64        break
 65      case "rent-set":
 66        cash.rent = parseFloat(ev.amount)
 67        break
 68      case "cap-set":
 69        cash.cap = ev.amount
 70        break
 71      case "task-boosted": // keep on card?
 72        cash.usedTxIds.push(ev.txid)
 73        break
 74      case "task-boosted-lightning":
 75        cash.pay_index = ev.pay_index
 76        break
 77      case "get-node-info":
 78        cash.info = ev.info
 79        break
 80      case "task-guilded":
 81        cash.pins = cash.pins.filter(p => p !== ev.taskId)
 82        if (ev.guild && ev.guild.split(':')[0]){
 83            cash.pins.push(ev.taskId)
 84        }
 85        break
 86      case "task-removed": 
 87        cash.pins = cash.pins.filter(p => p !== ev.taskId)
 88        break 
 89      case "tasks-received":
 90        ev.tasks.forEach(t => {
 91          cash.pins = cash.pins.filter(p => p !== ev.taskId)
 92        })
 93        ev.tasks.forEach(t => {
 94          if (t.guild && t.guild.split(':')[0]){
 95            cash.pins.push(t.taskId)
 96          }
 97        })
 98        break
 99    }
100  }
101  
102  function membersActions(members, ev) {
103    switch (ev.type) {
104      case "task-claimed":
105          members.forEach(member => {
106              if (member.memberId === ev.memberId  && member.action === ev.taskId) {
107                  member.action = false
108              }
109          })
110          break
111      case "ao-outbound-connected":
112        break
113      case "ao-disconnected":
114        break
115      case "member-created":
116        members.push(calculations.blankMember(ev.memberId, ev.name, ev.fob, ev.secret, ev.timestamp))
117        break
118      case "member-activated":
119        members.forEach(member => {
120          if (member.memberId === ev.memberId) {
121            if (member.active < 0) {
122              member.active = -1 * member.active
123            } else {
124              member.active++
125            }
126          }
127        })
128        break
129      case "task-boosted":
130        members.forEach(member => {
131          if (member.memberId === ev.taskId) {
132            if (member.active < 0) {
133              member.active = -1 * member.active
134            } else {
135              member.active++
136            }
137          }
138        })
139        break
140      case "task-boosted-lightning":
141        members.forEach(member => {
142          if (member.memberId === ev.taskId) {
143            if (member.active < 0) {
144              member.active = -1 * member.active
145            } else {
146              member.active++
147            }
148          }
149        })
150        break
151      case "member-deactivated":
152        members.forEach(member => {
153          if (member.memberId === ev.memberId) {
154            if (member.active > 0) {
155              member.active = -1 * member.active - 1
156            }
157          }
158        })
159        break
160      case "member-purged":
161        members.forEach((member, i) => {
162          if (member.memberId === ev.memberId) {
163            members.splice(i, 1)
164          }
165        })
166        break
167      case "member-field-updated":
168        members.forEach(member => {
169          if (member.memberId === ev.memberId) {
170            member[ev.field] = ev.newfield
171          }
172        })
173        break
174    }
175    members.forEach(member => {
176        if (member.memberId === ev.memberId  || ev.blame === member.memberId) {
177            member.lastUsed = ev.timestamp
178        }
179    })
180  }
181  let resourceIds
182  function resourcesActions(resources, ev) {
183    switch (ev.type) {
184      case "resource-created":
185        resourceIds = resources.map(r => r.resourceId)
186        if (resourceIds.indexOf(ev.resourceId) === -1) {
187          resources.push(ev)
188        } else {
189          console.log("BAD data duplicate resource rejected in mutation, dup resource task likely created")
190        }
191        break
192      case "resource-used":
193        resources.forEach(resource => {
194          if (resource.resourceId == ev.resourceId) {
195            resource.stock -= parseInt(ev.amount)
196          }
197        })
198        break
199      case "resource-purged":
200        resources.forEach((r, i) => {
201          if (r.resourceId === ev.resourceId) {
202            resources.splice(i, 1)
203          }
204        })
205        break
206      case "resource-stocked":
207        resources.forEach(resource => {
208          if (resource.resourceId == ev.resourceId) {
209            resource.stock += parseInt(ev.amount)
210          }
211        })
212        break
213    }
214  }
215  
216  let idHasSession
217  function sessionsActions(sessions, ev) {
218    switch (ev.type) {
219      case "session-created":
220        idHasSession = sessions.some(session => {
221          // replace that sessions creds,
222          let match = false
223          if (session.ownerId === ev.ownerId) {
224            match = true
225            Object.assign(session, ev)
226          }
227          return match // true terminates the some loop & idHasSession->true too
228        })
229  
230        if (idHasSession) {
231          // edited in session
232        } else {
233          // id didn't previously have session
234          sessions.push(ev)
235        }
236        break
237      case "session-killed":
238        sessions.forEach((s, i) => {
239          if (s.session == ev.session) {
240            sessions.splice(i, 1)
241          }
242        })
243        break
244      case "ao-outbound-connected":
245        sessions.push({
246          ownerId: ev.address,
247          token: ev.secret,
248          session: ev.address,
249        })
250        break
251      case "member-purged": 
252        sessions.forEach((s, i) => {
253          if (s.ownerId == ev.memberId) {
254            sessions.splice(i, 1)
255          }
256        })
257        break 
258      case "ao-disconnected": 
259        sessions.forEach((s, i) => {
260          if (s.ownerId == ev.address) {
261            sessions.splice(i, 1)
262          }
263        })
264        break 
265    }
266  }
267  
268  function hashMapActions(hashMap, ev){
269      let i
270      switch(ev.type){
271          case "ao-outbound-connected":
272              if (!hashMap[ev.address]) {
273                  hashMap[ev.address] = ev.i
274              }
275              break
276          case "ao-inbound-connected":
277              if (!hashMap[ev.address]) {
278                  hashMap[ev.address] = ev.i
279              }
280              break
281          case "task-created":
282              hashMap[ev.taskId] = ev.i
283              break
284          case "member-created":
285              hashMap[ev.memberId] = ev.i
286              break
287          case "resource-created":
288              hashMap[ev.resourceId] = ev.i
289              break
290          case "tasks-received":{
291              i = 0
292              ev.tasks.forEach(t => {
293                  if (!(hashMap[t.taskId] >= 0)){
294                      hashMap[t.taskId] = ev.i + i
295                      i ++
296                  }
297              })
298              }break
299          case "task-removed":
300              delete hashMap[ev.taskId]
301              Object.keys(hashMap).forEach(tId => {
302                  if (hashMap[tId] > ev.i){
303                      hashMap[tId] --
304                  }
305              })
306              break
307          case "ao-disconnected":
308              i = hashMap[ev.address]
309              delete hashMap[ev.address]
310              Object.keys(hashMap).forEach(tId => {
311                  if (hashMap[tId] > i){
312                      hashMap[tId] --
313                  }
314              })
315              break
316          case "member-purged":
317              i = hashMap[ev.memberId]
318              delete hashMap[ev.memberId]
319              Object.keys(hashMap).forEach(tId => {
320                  if (hashMap[tId] > i){
321                      hashMap[tId] --
322                  }
323              })
324              break
325          case "resource-purged":
326              i =  hashMap[ev.resourceId]
327              delete hashMap[ev.resourceId]
328              Object.keys(hashMap).forEach(tId => {
329                  if (hashMap[tId] > i){
330                      hashMap[tId] --
331                  }
332              })
333              break
334      }
335  }
336  
337  let explodingTask, absorbingTask, pirate, task, isExist, isExisting
338  function tasksActions(tasks, ev) {
339    switch (ev.type) {
340      case "task-colored":
341          tasks.forEach(task => {
342              if (task.taskId === ev.taskId) {
343                  task.color = ev.color
344              }
345              if (task.taskId === ev.inId){
346                  if (task.stackView[ev.color] !== -1){
347                      task.stackView[ev.color] = task.subTasks.length
348                  }
349                  task.subTasks = task.subTasks.filter(tId => tId !== ev.taskId)
350                  task.priorities = task.priorities.filter(tId => tId !== ev.taskId)
351                  task.subTasks.push(ev.taskId)
352                  tasks.forEach( taskLoop2 => { // dirty O(n^2)  ??
353                      if ( task.priorities.indexOf(taskLoop2.taskId) >= 0){
354                          taskLoop2.priorities = taskLoop2.priorities.filter(tId => tId !== ev.taskId)
355                      }
356                  })
357              }
358          })
359          break
360      case "ao-outbound-connected":
361          isExist = tasks.some(x => {
362              if (x.taskId === ev.address){
363                  return true
364              }
365          })
366          if (!isExist){
367              tasks.push(calculations.blankCard(ev.address, ev.address, 'blue', ev.timestamp))
368          }
369          break
370      case "ao-inbound-connected":
371          isExisting = tasks.some(x => {
372              if (x.taskId === ev.address){
373                  return true
374              }
375          })
376          if (!isExisting){
377              tasks.push(calculations.blankCard(ev.address, ev.address, 'red', ev.timestamp))
378          }
379          break
380      case "member-field-updated":
381        if (ev.field === 'action') {
382          tasks.forEach(task => {
383            if (task.taskId === ev.newfield) {
384              let editInline = task.actions.some(a => {
385                if (a.memberId === ev.memberId) {
386                  a.isActive = true
387                  a.timestamp = ev.timestamp
388                  return true
389                }
390              })
391              if (!editInline) {
392                task.actions.push({
393                  memberId: ev.memberId,
394                  timestamp: ev.timestamp,
395                  isActive: true,
396                  total: 0
397                })
398              }
399            } else {
400              task.actions.forEach(a => {
401                if (a.memberId === ev.memberId && a.isActive) {
402                  a.isActive = false
403                  a.total += (ev.timestamp - a.timestamp)
404                }
405              })
406            }
407          })
408        }
409        break
410      case "task-seized":
411  
412        tasks.forEach(task => {
413          if (task.taskId === ev.inId) {
414            pirate = task.priorities[task.priorities.indexOf(ev.taskId) + 1]
415            task.priorities = task.priorities.filter(taskId => taskId !== ev.taskId)
416          }
417        })
418        if (!pirate) pirate = ev.inId
419        tasks.forEach(task => {
420          if (task.taskId === pirate) {
421            task.priorities = task.priorities.filter(taskId => taskId !== ev.taskId)
422            task.priorities.push(ev.taskId)
423          }
424        })
425        break
426      case "task-touched":
427        tasks.forEach(task => {
428          if (task.taskId === ev.taskId) {
429            task.stackView[ev.stack] = ev.position
430          }
431        })
432        break
433      case "task-valued":
434        tasks.forEach(task => {
435          if (task.taskId === ev.taskId) {
436            task.completeValue = Number(ev.value)
437          }
438        })
439        break
440      case "task-popped":
441        tasks.forEach(task => {
442          if (task.taskId === ev.taskId) {
443            explodingTask = task
444          }
445          if (task.taskId === ev.inId) {
446            absorbingTask = task
447          }
448        })
449  
450        colors = []
451        tasks.forEach(task => { // im sorry
452            if (explodingTask.subTasks.indexOf(task.taskId) > -1){
453                colors.push(task.color)
454            }
455        })
456        if (explodingTask, absorbingTask) {
457          absorbingTask.priorities = absorbingTask.priorities.filter(taskId => taskId !== ev.taskId)
458          absorbingTask.subTasks = absorbingTask.subTasks.filter(taskId => taskId !== ev.taskId)
459          absorbingTask.completed = absorbingTask.completed.filter(taskId => taskId !== ev.taskId)
460          absorbingTask.subTasks = [...new Set(absorbingTask.subTasks.concat(explodingTask.subTasks))]
461          absorbingTask.priorities = [...new Set(absorbingTask.priorities.concat(explodingTask.priorities))]
462          colors.forEach(c => {
463              absorbingTask.stackView[c] = absorbingTask.subTasks.length - 1
464          })
465        }
466        break
467      case "pile-prioritized":
468        tasks.forEach(task => {
469          if (task.taskId === ev.inId) {
470            ev.tasks.forEach(tId => {
471                task.priorities.push(tId)
472            })
473            task.priorities = [...new Set(task.priorities)]
474          }
475        })
476        break
477      case "pile-refocused":
478        tasks.forEach(task => {
479          if (task.taskId === ev.inId) {
480            task.priorities.forEach(stId => {
481              tasks.forEach(st => {
482                if (st.taskId === stId) {
483                  task.subTasks.push(stId)
484                }
485              })
486              task.priorities = []
487            })
488          }
489        })
490        break
491      case "pile-de-sub-tasked":
492        tasks.forEach(task => {
493          if (task.taskId === ev.inId) {
494              task.subTasks = task.subTasks.filter(tId => ev.tasks.indexOf(tId) === -1)
495              task.priorities = task.priorities.filter(tId => ev.tasks.indexOf(tId) === -1)
496          }
497        })
498        break
499      case "pile-sub-tasked":
500        colors = []
501        tasks.forEach(task => {
502            if (ev.tasks.indexOf(task.taskId) >= 0){
503                colors.push(task.color)
504            }
505        })
506        tasks.forEach(task => {
507          if (task.taskId === ev.inId) {
508            task.subTasks = task.subTasks.filter(tId => ev.tasks.indexOf(tId) === -1)
509            task.priorities = task.priorities.filter(tId => ev.tasks.indexOf(tId) === -1)
510            task.subTasks = task.subTasks.concat(ev.tasks)
511            colors.forEach( c => {
512                task.stackView[c] = task.subTasks.length - 1
513            })
514          }
515        })
516        break
517      case "completed-toggled":
518          tasks.forEach(task => {
519              if (task.taskId === ev.taskId) {
520                  if (task.stackView.completed){
521                      task.highlights = []
522                  }
523                  task.stackView.completed = !task.stackView.completed
524              }
525          })
526          break
527      case "highlighted":
528        tasks.forEach(task => {
529          if (task.taskId === ev.taskId) {
530              let didUpdateInline = false
531              task.highlights.forEach((h, i) => {
532                if (h.memberId === ev.memberId) {
533                  didUpdateInline = true
534                  if (h.valence === ev.valence) {
535                    task.highlights.splice(i, 1)
536                  } else {
537                    h.valence = ev.valence
538                  }
539                }
540              })
541              if (!didUpdateInline) {
542                task.highlights.push({
543                  memberId: ev.memberId,
544                  valence: ev.valence
545                })
546              }
547              if (task.highlights.length > 0){
548                  task.stackView.completed = true
549              } 
550          }
551        })
552        break
553      case "resource-created":
554        tasks.push(calculations.blankCard(ev.resourceId, ev.resourceId, 'red', ev.timestamp, [ev.memberId], [ev.resourceId]))
555        break
556      case "member-created":
557        tasks.push(calculations.blankCard(ev.memberId, ev.memberId, 'purple', ev.timestamp))
558        break
559      case "task-created":
560        tasks.push(calculations.blankCard(ev.taskId, ev.name, ev.color, ev.timestamp, ev.deck))
561        tasks.forEach(task => {
562          if (task.taskId === ev.inId) {
563            task.subTasks = task.subTasks.filter(tId => tId !== ev.taskId)
564            task.subTasks.push(ev.taskId)
565            if (task.deck.indexOf(ev.memberId) === -1){
566                task.deck.push(ev.memberId)
567            }
568            task.stackView.completed = false
569            if (task.stackView[ev.color] > -1){
570                task.stackView[ev.color] = task.subTasks.length - 1
571            }
572          }
573        })
574        break
575      case "address-updated":
576        tasks.forEach(t => {
577          if (t.taskId === ev.taskId) {
578            t.btcAddr = ev.btcAddr
579          }
580        })
581        break
582      case "task-grabbed":
583        tasks.forEach(task => {
584          if (task.taskId === ev.taskId) {
585            if (task.deck.indexOf(ev.memberId) === -1) {
586              if (ev.taskId !== ev.memberId && ev.memberId) {
587                task.deck.push(ev.memberId)
588              }
589            }
590          }
591        })
592        break
593      case "pile-grabbed":
594        if (!ev.memberId) { // what?
595            break
596        }
597        tasks.forEach(task => {
598          if (task.taskId === ev.taskId) {
599            let crawler = [ev.taskId]
600            let history = []
601            let newCards = []
602            do {
603              newCards = []
604              crawler = crawler.forEach(t => {
605                if (history.indexOf(t) >= 0) return
606                let subTask = tasks.filter(pst => pst.taskId === t)
607                if (subTask.length < 1) {
608                  console.log("missing subtask, this is messy", t)
609                  return
610                }
611                if (subTask.length > 1) {
612                  console.log("duplicate task found, this is very bad")
613                }
614                subTask = subTask[0]
615                if (subTask === undefined || subTask.subTasks === undefined || subTask.priorities === undefined || subTask.completed === undefined) {
616                  console.log("invalid task data found, this is very bad")
617                  return
618                }
619  
620                history.push(t)
621  
622                if (subTask.deck.indexOf(ev.memberId) === -1 && ev.taskId !== ev.memberId) {
623                  subTask.deck.push(ev.memberId)
624                }
625                newCards = newCards.concat(subTask.subTasks).concat(subTask.priorities).concat(subTask.completed)
626              })
627              crawler = newCards
628            } while (crawler.length > 0)
629          }
630        })
631        break
632      case "task-dropped":
633        tasks.forEach(task => {
634          if (task.taskId === ev.taskId) {
635            task.deck = task.deck.filter(d => d !== ev.memberId)
636          }
637        })
638        break
639      case "pile-dropped":
640        if (!ev.memberId) {
641          break
642        }
643        tasks.forEach(task => {
644          if (task.taskId === ev.taskId) {
645            let crawler = [ev.taskId]
646            let history = []
647            let newCards = []
648            do {
649              newCards = []
650              crawler = crawler.forEach(t => {
651                if (history.indexOf(t) >= 0) return
652                let subTask = tasks.filter(pst => pst.taskId === t)
653                if (subTask.length < 1) {
654                  console.log('missing subtask, this is messy', t)
655                  return
656                }
657                if (subTask.length > 1) {
658                  console.log('duplicate task found, this is very bad')
659                }
660                subTask = subTask[0]
661                if (subTask === undefined || subTask.subTasks === undefined || subTask.priorities === undefined || subTask.completed === undefined) {
662                  console.log('invalid task data found, this is very bad')
663                  return
664                }
665  
666                history.push(t)
667  
668                if (subTask.deck.indexOf(ev.memberId) >= 0 && ev.taskId !== ev.memberId) {
669                  subTask.deck = subTask.deck.filter(d => d !== ev.memberId)
670                }
671                newCards = newCards.concat(subTask.subTasks).concat(subTask.priorities).concat(subTask.completed)
672              })
673              crawler = newCards
674            } while (crawler.length > 0)
675          }
676        })
677        break
678      case "ao-disconnected":
679        tasks.forEach((task, i) => {
680          if (task.taskId === ev.address) {
681            tasks.splice(i, 1)
682          }
683        })
684        tasks.forEach(t => {
685            t.subTasks = t.subTasks.filter(st => st !== ev.address)
686            t.priorities = t.priorities.filter(st => st !== ev.address)
687            t.completed = t.completed.filter(st => st !== ev.address)
688            t.claimed = t.claimed.filter(st => st !== ev.address)
689            t.claims = t.claims.filter(cl => cl.memberId !== ev.address)
690            t.deck = t.deck.filter(st => st !== ev.address)
691            if (t.book & (t.book.resourceId === ev.address || t.book.memberId === ev.address)) t.book = {}
692        })
693        break
694      case "member-purged":
695        tasks.forEach((task, i) => {
696          if (task.taskId === ev.memberId) {
697            tasks.splice(i, 1)
698          }
699        })
700        tasks.forEach(t => {
701            t.subTasks = t.subTasks.filter(st => st !== ev.memberId)
702            t.priorities = t.priorities.filter(st => st !== ev.memberId)
703            t.completed = t.completed.filter(st => st !== ev.memberId)
704            t.claimed = t.claimed.filter(st => st !== ev.memberId )
705            t.claims = t.claims.filter(cl => cl.memberId !== ev.memberId)
706            t.deck = t.deck.filter(st => st !== ev.memberId)
707            if (t.book & (t.book.resourceId === ev.memberId || t.book.memberId === ev.memberId)) t.book = {}
708        })
709        break
710      case "task-removed":
711        tasks.forEach((task, i) => {
712          if (task.taskId === ev.taskId) {
713            tasks.splice(i, 1)
714          }
715        })
716        tasks.forEach(t => {
717          t.subTasks = t.subTasks.filter(st => st !== ev.taskId)
718          t.priorities = t.priorities.filter(st => st !== ev.taskId)
719          t.completed = t.completed.filter(st => st !== ev.taskId)
720          t.claims = t.claims.filter(cl => cl.taskId !== ev.taskId)
721        })
722        break
723      case "task-prioritized":
724        tasks.forEach(task => {
725          if (task.taskId === ev.fromId){
726              task.subTasks = task.subTasks.filter(taskId => taskId !== ev.taskId)
727              task.priorities = task.priorities.filter(taskId => taskId !== ev.taskId)
728              tasks.forEach( taskLoop2 => {
729                  if ( task.priorities.indexOf(taskLoop2.taskId) >= 0){
730                      taskLoop2.priorities = taskLoop2.priorities.filter(tId => tId !== ev.taskId)
731                  }
732              })
733          }
734          if (task.taskId === ev.inId) {
735            task.priorities = task.priorities.filter(taskId => taskId !== ev.taskId)
736            task.subTasks = task.subTasks.filter(taskId => taskId !== ev.taskId)
737            task.priorities.push(ev.taskId)
738          }
739          if (task.taskId === ev.taskId && task.deck.indexOf(ev.blame) === -1){
740              task.deck.push(ev.blame)
741          }
742        })
743        break
744      case "task-completed":
745        tasks.forEach(task => {
746          if (task.taskId === ev.inId) {
747            task.priorities = task.priorities.filter(taskId => taskId !== ev.taskId)
748            task.subTasks = task.subTasks.filter(taskId => taskId !== ev.taskId)
749            task.completed = task.completed.filter(taskId => taskId !== ev.taskId)
750            task.completed.push(ev.taskId)
751          }
752        })
753        break
754      case "task-sub-tasked":
755        color = false
756        tasks.forEach(task => { // sorry need hashmap
757          if (task.taskId === ev.taskId){
758              color = task.color
759          }
760        })
761        tasks.forEach(task => {
762          if (task.taskId === ev.taskId && task.deck.indexOf(ev.blame) === -1){
763                task.deck.push(ev.blame)
764          }
765          if (task.taskId === ev.inId) {
766            task.priorities = task.priorities.filter(taskId => taskId !== ev.taskId)
767            task.subTasks = task.subTasks.filter(tId => tId !== ev.taskId)
768            task.subTasks.push(ev.taskId)
769            if (color){
770                task.stackView[color] = task.subTasks.length - 1
771            }
772          }
773        })
774        break
775      case "task-de-sub-tasked":
776        tasks.forEach(task => {
777          if (task.taskId === ev.inId) {
778              task.priorities = task.priorities.filter(tId => tId !== ev.taskId)
779              task.subTasks = task.subTasks.filter(tId => tId !== ev.taskId)
780          }
781        })
782        break
783      case "task-guilded":
784        tasks.forEach(task => {
785          if (task.taskId === ev.taskId) {
786            task.guild = ev.guild
787          }
788        })
789        break
790      case "task-claimed":
791        tasks.forEach(task => {
792          if (task.taskId === ev.taskId) {
793            if (task.deck.indexOf(ev.memberId) === -1) {
794              if (ev.taskId !== ev.memberId && ev.memberId) {
795                task.deck.push(ev.memberId)
796              }
797            }
798            if (task.claimed.indexOf(ev.memberId) === -1) {
799              task.claimed.push(ev.memberId)
800            }
801            task.claims.push(ev)
802            task.lastClaimed = ev.timestamp
803          }
804  
805          if (ev.inId !== ev.taskId && task.taskId === ev.inId) {
806              if (task.completed.indexOf(ev.taskId) === -1){
807                  task.completed.push(ev.taskId)
808                  if (task.deck.indexOf(ev.memberId) === -1) {
809                      task.deck.push(ev.memberId)
810                  }
811              }
812          }
813  
814        })
815        break
816      case "task-unclaimed":
817        tasks.forEach(task => {
818          if (task.taskId === ev.taskId) {
819              task.claimed = task.claimed.filter(mId => mId !== ev.memberId)
820          }
821          if (task.taskId === ev.inId){
822              task.completed = task.completed.filter(taskId => taskId !== ev.taskId)
823          }
824        })
825        break
826      case "task-boosted":
827        tasks.forEach(task => {
828          if (task.taskId === ev.taskId) {
829            let amount = Number(ev.amount)
830            let boost = Number(task.boost)
831            if (amount + boost > 0) {
832              task.boost = amount + boost
833            }
834            task.payments.push(ev)
835          }
836        })
837        break
838      case "task-boosted-lightning":
839        tasks.forEach(task => {
840          if (task.payment_hash === ev.payment_hash  && ev.taskId === task.taskId) {
841            let amount = parseFloat(ev.amount)
842            let boost = parseFloat(task.boost)
843            if (amount > 0) {
844              task.boost = amount + boost
845              task.bolt11 = ""
846              task.payment_hash = ""
847            }
848            task.payments.push(ev)
849          }
850        })
851        break
852      case "resource-booked":
853        tasks.forEach(task => {
854          if (task.taskId === ev.resourceId) {
855            task.book = ev
856          }
857        })
858        break
859      case "resource-used":
860        tasks.forEach(task => {
861          let charged = parseFloat(ev.charged)
862          if (task.taskId === ev.memberId) {
863            if (charged > 0) {
864              task.boost -= charged
865            }
866            task.claims.push(ev) //
867          }
868          if (task.taskId === ev.resourceId) {
869              task.claims.push(ev) //
870          }
871        })
872        break
873      case "invoice-created":
874        tasks.forEach(task => {
875          if (task.taskId === ev.taskId) {
876            task.payment_hash = ev.payment_hash
877            task.bolt11 = ev.bolt11
878          }
879        })
880        break
881      case "task-swapped":
882        tasks.forEach((t) => {
883          if (t.taskId === ev.taskId) {
884            task = t
885          }
886        })
887  
888        if (task) {
889          let originalIndex = task.subTasks.indexOf(ev.swapId1)
890          let swapIndex = task.subTasks.indexOf(ev.swapId2)
891          let originalIndexCompleted = task.completed.indexOf(ev.swapId1)
892          let swapIndexCompleted = task.completed.indexOf(ev.swapId2)
893  
894          if (originalIndex > -1 && swapIndex > -1 && originalIndex > swapIndex) {
895            let newST = task.subTasks.slice()
896            newST[originalIndex] = ev.swapId2
897            newST[swapIndex] = ev.swapId1
898            task.subTasks = newST
899          }
900  
901          if (originalIndexCompleted > -1 && swapIndexCompleted > -1 && originalIndexCompleted > swapIndexCompleted) {
902            let newCompleted = task.completed.slice()
903            newCompleted[originalIndexCompleted] = ev.swapId2
904            newCompleted[swapIndexCompleted] = ev.swapId1
905            task.completed = newCompleted
906          }
907        }
908        break
909      case "tasks-received":
910        ev.tasks.forEach(newT => {
911          if (!tasks.some(cur => {
912              if (cur.taskId === newT.taskId) {
913                calculations.safeMerge(cur, newT)
914                return true
915              }
916            })) {
917            tasks.push(newT)
918          }
919        })
920        break
921      case "member-charged":
922        tasks.forEach(task => {
923          if (task.taskId === ev.memberId) {
924            task.boost -= parseFloat(ev.charged)
925            if (task.boost < 0) {
926              task.boost = 0
927            }
928          }
929        })
930        break
931    }
932    tasks.forEach( t => {
933        if (t.taskId === ev.inId) {
934            t.lastUsed = ev.timestamp
935        }
936    })
937  }
938  
939  export default {
940    aoActions,
941    cashActions,
942    membersActions,
943    resourcesActions,
944    sessionsActions,
945    tasksActions,
946    hashMapActions
947  }