1  import cryptoUtils from '../crypto.js'
  2  import state from './state.js'
  3  const { serverState } = state
  4  import dctrlDb from './dctrlDb.js'
  5  
  6  function completedToggled(taskId, blame, callback){
  7      let newEvent = {
  8          type: "completed-toggled",
  9          taskId,
 10          blame,
 11      }
 12      dctrlDb.insertEvent(newEvent, callback)
 13  }
 14  
 15  function taskColored(taskId, inId, color, blame, callback){
 16      let newEvent = {
 17          type: "task-colored",
 18          taskId,
 19          inId,
 20          color,
 21          blame,
 22      }
 23      dctrlDb.insertEvent(newEvent, callback)
 24  }
 25  
 26  function taskSeized(taskId, inId, callback){
 27    let newEvent = {
 28        type: "task-seized",
 29        taskId,
 30        inId,
 31    }
 32    dctrlDb.insertEvent(newEvent, callback)
 33  }
 34  
 35  function taskTouched(taskId, stack, position, memberId, callback){
 36      let newEvent = {
 37          type: "task-touched",
 38          taskId,
 39          stack,
 40          position,
 41          memberId,
 42      }
 43      dctrlDb.insertEvent(newEvent, callback)
 44  }
 45  
 46  
 47  function taskCompleted(taskId, inId, blame, callback){
 48      let newEvent = {
 49        type: "task-completed",
 50        taskId,
 51        inId,
 52        blame,
 53      }
 54      dctrlDb.insertEvent(newEvent, callback)
 55  }
 56  
 57  function taskValued(taskId, value, blame, callback) {
 58    let newEvent = {
 59      type: "task-valued",
 60      taskId,
 61      value,
 62      blame
 63    }
 64    dctrlDb.insertEvent(newEvent, callback)
 65  }
 66  
 67  function highlighted(taskId, memberId, valence, blame, callback){
 68      let newEvent = {
 69          type: "highlighted",
 70          taskId,
 71          memberId,
 72          valence,
 73          blame,
 74      }
 75      dctrlDb.insertEvent(newEvent, callback)
 76  }
 77  
 78  function aoInboundConnected(address, alias, secret, callback){
 79      let newEvent = {
 80          type: "ao-inbound-connected",
 81          address,
 82          alias,
 83          secret,
 84          i: serverState.tasks.length,
 85      }
 86      dctrlDb.insertEvent(newEvent, callback)
 87  }
 88  
 89  function aoOutboundConnected(address, secret, callback) {
 90      let newEvent = {
 91          type: "ao-outbound-connected",
 92          address,
 93          secret,
 94          i: serverState.tasks.length,
 95      }
 96      dctrlDb.insertEvent(newEvent, callback)
 97  }
 98  
 99  function aoDisconnected(address, callback) {
100      let newEvent = {
101          type: "ao-disconnected",
102          address,
103          i: serverState.tasks.length,
104      }
105      dctrlDb.insertEvent(newEvent, callback)
106  }
107  
108  function getNodeInfo(info, callback){
109      let newEvent = {
110          type: "get-node-info",
111          info
112      }
113      dctrlDb.triggerShadow(newEvent)
114  }
115  
116  function rentSet(amount, callback){
117      let newEvent = {
118        type: "rent-set",
119        amount
120      }
121      dctrlDb.insertEvent(newEvent, callback)
122  }
123  
124  function capSet(amount, callback){
125      let newEvent = {
126        type: "cap-set",
127        amount
128      }
129      dctrlDb.insertEvent(newEvent, callback)
130  }
131  
132  function spotUpdated(spot, callback) {
133    let newEvent = {
134        type: "spot-updated",
135        spot
136    }
137    dctrlDb.triggerShadow(newEvent)
138  }
139  
140  function currencySwitched(currency, callback) {
141    let newEvent = {
142        type: "currency-switched",
143        currency
144    }
145    dctrlDb.insertEvent(newEvent, callback)
146  }
147  
148  function memberCreated(name, fob, secret, callback) {
149        let memberId = crypto.randomUUID()
150        let newEvent = {
151            type: "member-created",
152            memberId,
153            name,
154            fob,
155            secret,
156            i: serverState.tasks.length
157        }
158        dctrlDb.insertEvent(newEvent, callback)
159  }
160  
161  function memberDeactivated(memberId, callback) {
162    let newEvent = {
163      type: "member-deactivated",
164      memberId,
165    }
166    dctrlDb.insertEvent(newEvent, callback)
167  }
168  
169  function memberPurged(memberId, blame, callback) {
170    let newEvent = {
171      type: "member-purged",
172      memberId,
173      blame,
174      i: serverState.hashMap[memberId]
175    }
176    dctrlDb.insertEvent(newEvent, callback)
177  }
178  
179  function memberActivated(memberId, callback) {
180    let newEvent = {
181      type: "member-activated",
182      memberId,
183    }
184    dctrlDb.insertEvent(newEvent, callback)
185  }
186  
187  function memberFieldUpdated(memberId, field, newfield, callback){
188    let newEvent = {
189      type: "member-field-updated",
190      memberId,
191      field,
192      newfield,
193    }
194    dctrlDb.insertEvent(newEvent, callback)
195  }
196  
197  function resourceCreated(resourceId, name, charged, secret, trackStock, callback) {
198      let newEvent = {
199          type: "resource-created",
200          resourceId,
201          name,
202          charged,
203          secret,
204          info: {},
205          i: serverState.tasks.length
206      }
207      if (trackStock) {
208          newEvent.stock = 0
209      }
210      dctrlDb.insertEvent(newEvent, callback)
211  }
212  
213  function resourceStocked(resourceId, memberId, amount, paid, notes, callback) {
214    let newEvent = {
215        type: 'resource-stocked',
216        resourceId,
217        memberId,
218        amount,
219        paid,
220        notes,
221    }
222    dctrlDb.insertEvent(newEvent, callback)
223  }
224  
225  function resourceUsed(resourceId, memberId, charged, notes, callback) {
226    let newEvent = {
227        type: 'resource-used',
228        resourceId,
229        memberId,
230        charged,
231        notes
232    }
233    dctrlDb.insertEvent(newEvent, callback)
234  }
235  
236  function resourceBooked(resourceId, memberId, startTs, endTs, charge, notes, callback) {
237    let newEvent = {
238        type: 'resource-booked',
239        resourceId,
240        memberId,
241        startTs,
242        endTs,
243        charge,
244        notes,
245    }
246    dctrlDb.insertEvent(newEvent, callback)
247  }
248  
249  function bookCancelled(resourceId, bookTime, callback){
250    let newEvent = {
251        type: 'book-cancelled',
252        resourceId,
253        bookTime,
254    }
255    dctrlDb.insertEvent(newEvent, callback)
256  }
257  
258  function resourcePurged(resourceId, blame, callback) {
259    let newEvent = {
260      type: "resource-purged",
261      resourceId,
262      blame,
263      i: serverState.hashMap[resourceId]
264    }
265    dctrlDb.insertEvent(newEvent, callback)
266  }
267  
268  function sessionCreated(ownerId, session, token, callback) {
269      let newEvent = {
270          type: "session-created",
271          session,
272          token,
273          ownerId
274      }
275      dctrlDb.insertEvent(newEvent, callback)
276  }
277  
278  function sessionKilled(session, callback) {
279      let newEvent = {
280          type: "session-killed",
281          session
282      }
283      dctrlDb.insertEvent(newEvent, callback)
284  }
285  
286  function taskCreated(name, color, deck, inId, memberId, callback) {
287      let hash = cryptoUtils.createCardHash(name)
288      let isExist = false
289      serverState.tasks.forEach( t => {
290          if (t.taskId === hash || t.hash === hash){
291              isExist = true
292          }
293      })
294      if (isExist) return callback('err exists')
295      let newEvent = {
296          type: "task-created",
297          taskId: hash,
298          name,
299          color,
300          deck,
301          inId,
302          memberId,
303          i: serverState.tasks.length
304      }
305      dctrlDb.insertEvent(newEvent, callback)
306  }
307  
308  function addressUpdated(taskId, btcAddr, blame, callback){
309        dctrlDb.insertEvent({
310            type: "address-updated",
311            taskId,
312            btcAddr,
313            blame,
314        }, callback)
315  }
316  
317  function taskGuilded(taskId, guild, blame, callback){
318      let newEvent = {
319          type: "task-guilded",
320          taskId,
321          guild,
322          blame,
323      }
324      dctrlDb.insertEvent(newEvent, callback)
325  }
326  
327  function taskSubTasked(taskId, inId, blame, callback){
328      let newEvent = {
329        type: "task-sub-tasked",
330        taskId,
331        inId,
332        blame,
333      }
334      dctrlDb.insertEvent(newEvent, callback)
335  }
336  
337  function taskDeSubTasked(taskId, inId, blame, callback){
338      let newEvent = {
339        type: "task-de-sub-tasked",
340        taskId,
341        inId,
342        blame,
343      }
344      dctrlDb.insertEvent(newEvent, callback)
345  }
346  
347  function pileSubTasked(inId, tasks, blame, callback){
348      let newEvent = {
349        type: "pile-sub-tasked",
350        inId,
351        tasks,
352        blame,
353      }
354      dctrlDb.insertEvent(newEvent, callback)
355  }
356  
357  function pileDeSubTasked(inId, tasks, blame, callback){
358      let newEvent = {
359        type: "pile-de-sub-tasked",
360        inId,
361        tasks,
362        blame,
363      }
364      dctrlDb.insertEvent(newEvent, callback)
365  }
366  
367  function taskPrioritized(taskId, inId, fromId, blame, callback){
368      let newEvent = {
369        type: "task-prioritized",
370        taskId,
371        inId,
372        fromId,
373        blame,
374      }
375      dctrlDb.insertEvent(newEvent, callback)
376  }
377  
378  function pilePrioritized(inId, tasks, blame, callback) {
379    let newEvent = {
380      type: "pile-prioritized",
381      inId,
382      tasks,
383      blame,
384    };
385    dctrlDb.insertEvent(newEvent, callback);
386  }
387  
388  function taskPopped(taskId, inId, blame, callback){
389      let newEvent = {
390        type: "task-popped",
391        taskId,
392        inId,
393        blame
394      }
395      dctrlDb.insertEvent(newEvent, callback)
396  }
397  
398  function taskGrabbed(taskId, memberId, callback){
399      let newEvent = {
400        type: "task-grabbed",
401        taskId,
402        memberId,
403      }
404      dctrlDb.insertEvent(newEvent, callback)
405  }
406  
407  function taskDropped(taskId, memberId, callback){
408      let newEvent = {
409        type: "task-dropped",
410        taskId,
411        memberId,
412      }
413      dctrlDb.insertEvent(newEvent, callback)
414  }
415  
416  function taskClaimed(taskId, memberId, inId, callback) {
417    let newEvent = {
418      type: "task-claimed",
419      taskId,
420      memberId,
421      inId,
422    }
423    dctrlDb.insertEvent(newEvent, callback)
424  }
425  
426  function taskUnclaimed(taskId, memberId, inId, callback) {
427    let newEvent = {
428      type: "task-unclaimed",
429      taskId,
430      memberId,
431      inId,
432    }
433    dctrlDb.insertEvent(newEvent, callback)
434  }
435  
436  function taskBoosted(taskId, amount, txid, callback) {
437    let newEvent = {
438        type: "task-boosted",
439        taskId,
440        amount,
441        txid,
442    }
443    dctrlDb.insertEvent(newEvent, callback)
444  }
445  
446  function taskBoostedLightning(taskId, amount, payment_hash, pay_index, callback) {
447    let newEvent = {
448        type: "task-boosted-lightning",
449        taskId,
450        amount,
451        payment_hash,
452        pay_index,
453    }
454    dctrlDb.insertEvent(newEvent, callback)
455  }
456  
457  function taskRemoved(taskId, blame, callback){
458    let newEvent = {
459      type: "task-removed",
460      taskId,
461      blame,
462      i: serverState.hashMap[taskId]
463    }
464    dctrlDb.insertEvent(newEvent, callback)
465  }
466  
467  function taskSwapped(taskId, swapId1, swapId2, blame, callback){
468    let newEvent = {
469      type: "task-swapped",
470      taskId,
471      swapId1,
472      swapId2,
473      blame,
474    }
475    dctrlDb.insertEvent(newEvent, callback)
476  }
477  
478  function tasksReceived(tasks, blame, callback) {
479    let newEvent = {
480      type: "tasks-received",
481      tasks,
482      blame,
483      i: serverState.tasks.length
484    }
485    dctrlDb.insertEvent(newEvent, callback)
486  }
487  
488  function invoiceCreated(taskId, bolt11, payment_hash, blame, callback){
489      let newEvent = {
490          type: "invoice-created",
491          taskId,
492          bolt11,
493          payment_hash,
494          blame,
495      }
496      dctrlDb.insertEvent(newEvent, callback)
497  }
498  
499  function memberCharged(memberId, charged, notes, callback) {
500      let newEvent = {
501          type: "member-charged",
502          memberId,
503          charged,
504          notes,
505      }
506      dctrlDb.insertEvent(newEvent, callback)
507  }
508  
509  export default {
510      highlighted,
511      memberCharged,
512      aoOutboundConnected,
513      aoDisconnected,
514      aoInboundConnected,
515      spotUpdated,
516      rentSet,
517      capSet,
518      getNodeInfo,
519      memberCreated,
520      memberDeactivated,
521      memberPurged,
522      memberActivated,
523      memberFieldUpdated,
524      resourceCreated,
525      resourceUsed,
526      resourceStocked,
527      resourceBooked,
528      bookCancelled,
529      resourcePurged,
530      sessionCreated,
531      sessionKilled,
532      taskCreated,
533      taskBoosted,
534      taskClaimed,
535      taskUnclaimed,
536      taskRemoved,
537      taskSwapped,
538      taskGrabbed,
539      taskPrioritized,
540      taskPopped,
541      taskDropped,
542      taskGuilded,
543      taskSubTasked,
544      taskDeSubTasked,
545      addressUpdated,
546      invoiceCreated,
547      taskBoostedLightning,
548      tasksReceived,
549      pilePrioritized,
550      pileSubTasked,
551      pileDeSubTasked,
552      taskValued,
553      taskCompleted,
554      taskTouched,
555      taskSeized,
556      taskColored,
557      completedToggled,
558  }