From 331846ecf7faa43b022a1fa65df9139f136cdb80 Mon Sep 17 00:00:00 2001
From: Eric Harris-Braun <eric@harris-braun.com>
Date: Mon, 2 Sep 2024 17:18:36 -0400
Subject: [PATCH] adds bunches and things

---
 dnas/ziptest/workdir/dna.yaml                 |   2 +-
 .../zomes/coordinator/ziptest/src/lib.rs      |   1 +
 .../zomes/coordinator/ziptest/src/thing.rs    |  58 ++++--
 .../zomes/coordinator/ziptest/src/utils.rs    |  27 +++
 ui/src/Bunch.svelte                           | 115 ++++++++++++
 ui/src/Controller.svelte                      |   1 +
 ui/src/ControllerStream.svelte                |   1 -
 ui/src/ThingsPane.svelte                      | 171 +++++++++++++-----
 ui/src/store.ts                               |  62 ++-----
 ui/src/thingStore.ts                          |   6 +-
 10 files changed, 336 insertions(+), 108 deletions(-)
 create mode 100644 dnas/ziptest/zomes/coordinator/ziptest/src/utils.rs
 create mode 100644 ui/src/Bunch.svelte

diff --git a/dnas/ziptest/workdir/dna.yaml b/dnas/ziptest/workdir/dna.yaml
index 34e3269..33de56c 100644
--- a/dnas/ziptest/workdir/dna.yaml
+++ b/dnas/ziptest/workdir/dna.yaml
@@ -18,7 +18,7 @@ coordinator:
     - name: ziptest
       bundled: ../../../target/wasm32-unknown-unknown/release/ziptest.wasm
       dependencies:
-        - name: profiles_integrity
+        - name: ziptest_integrity
     - name: profiles
       bundled: ../../../target/wasm32-unknown-unknown/release/profiles.wasm
       dependencies:
diff --git a/dnas/ziptest/zomes/coordinator/ziptest/src/lib.rs b/dnas/ziptest/zomes/coordinator/ziptest/src/lib.rs
index 845d14b..c9eabaa 100644
--- a/dnas/ziptest/zomes/coordinator/ziptest/src/lib.rs
+++ b/dnas/ziptest/zomes/coordinator/ziptest/src/lib.rs
@@ -1,4 +1,5 @@
 pub mod thing;
+pub mod utils;
 use ziptest_integrity::*;
 
 use hdk::prelude::*;
diff --git a/dnas/ziptest/zomes/coordinator/ziptest/src/thing.rs b/dnas/ziptest/zomes/coordinator/ziptest/src/thing.rs
index 2ee9428..93c6404 100644
--- a/dnas/ziptest/zomes/coordinator/ziptest/src/thing.rs
+++ b/dnas/ziptest/zomes/coordinator/ziptest/src/thing.rs
@@ -1,19 +1,50 @@
 use hdk::prelude::*;
 use ziptest_integrity::*;
+use crate::utils::*;
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct CreateThingInput {
+    pub thing: Thing,
+    pub bunch: String,
+    pub reps: Option<u32>,
+    pub tag: Option<String>,
+}
 
 #[hdk_extern]
-pub fn create_thing(thing: Thing) -> ExternResult<Record> {
-    let thing_hash = create_entry(&EntryTypes::Thing(thing.clone()))?;
-    let record = get(thing_hash.clone(), GetOptions::default())?
-        .ok_or(
-            wasm_error!(
-                WasmErrorInner::Guest(String::from("Could not find the newly created Thing"))
-            ),
-        )?;
-    let path = Path::from("all_things");
-    create_link(path.path_entry_hash()?, thing_hash.clone(), LinkTypes::AllThings, ())?;
-    Ok(record)
+pub fn create_thing(input: CreateThingInput) -> ExternResult<Vec<Record>> {
+    let mut i = 0;
+    let mut results = Vec::new();
+    let mut reps = 1;
+    if let Some(r) = input.reps {
+        reps = r;
+    }
+    while i<reps {
+        let content = if input.reps.is_some() {
+            format!("{}:{}",i,input.thing.content)
+        } else {
+            input.thing.content.clone()
+        };
+
+        let thing = Thing {content};
+        let thing_hash = create_entry(&EntryTypes::Thing(thing))?;
+        let record = get(thing_hash.clone(), GetOptions::default())?
+            .ok_or(
+                wasm_error!(
+                    WasmErrorInner::Guest(String::from("Could not find the newly created Thing"))
+                ),
+            )?;
+        let path = Path::from(input.bunch.clone());
+        let tag = match input.tag.clone() {
+            Some(str) => LinkTag::from(str),
+            None => LinkTag::from(())
+        };
+        create_link_relaxed(path.path_entry_hash()?, thing_hash.clone(), LinkTypes::AllThings, tag)?;
+        results.push(record);
+        i+=1;
+    }
+    Ok(results)
 }
+
 #[hdk_extern]
 pub fn get_thing(original_thing_hash: ActionHash) -> ExternResult<Option<Record>> {
     let input = GetLinksInputBuilder::try_new(original_thing_hash.clone(), LinkTypes::ThingUpdates)?.build();
@@ -60,10 +91,9 @@ pub fn delete_thing(original_thing_hash: ActionHash) -> ExternResult<ActionHash>
 }
 
 #[hdk_extern]
-pub fn get_things(_: ()) -> ExternResult<Vec<Link>> {
-    let path = Path::from("all_things");
+pub fn get_things(bunch: String) -> ExternResult<Vec<Link>> {
+    let path = Path::from(bunch.clone());
     let input = GetLinksInputBuilder::try_new(path.path_entry_hash()?, LinkTypes::AllThings)?.build();
     let links = get_links(input)?;
-
     Ok(links)
 }
\ No newline at end of file
diff --git a/dnas/ziptest/zomes/coordinator/ziptest/src/utils.rs b/dnas/ziptest/zomes/coordinator/ziptest/src/utils.rs
new file mode 100644
index 0000000..5d3dcea
--- /dev/null
+++ b/dnas/ziptest/zomes/coordinator/ziptest/src/utils.rs
@@ -0,0 +1,27 @@
+use hdk::prelude::*;
+
+pub fn create_link_relaxed<T, E>(
+    base_address: impl Into<AnyLinkableHash>,
+    target_address: impl Into<AnyLinkableHash>,
+    link_type: T,
+    tag: impl Into<LinkTag>
+)  -> ExternResult<ActionHash>
+where 
+ScopedLinkType: TryFrom<T, Error = E>,
+    WasmError: From<E>,
+{
+    let ScopedLinkType {
+        zome_index,
+        zome_type: link_type,
+    } = link_type.try_into()?;
+    HDK.with(|h| {
+        h.borrow().create_link(CreateLinkInput::new(
+            base_address.into(),
+            target_address.into(),
+            zome_index,
+            link_type,
+            tag.into(),
+            ChainTopOrdering::Relaxed,
+        ))
+    })
+}
\ No newline at end of file
diff --git a/ui/src/Bunch.svelte b/ui/src/Bunch.svelte
new file mode 100644
index 0000000..99f5bfd
--- /dev/null
+++ b/ui/src/Bunch.svelte
@@ -0,0 +1,115 @@
+<script lang="ts">
+  import { createEventDispatcher, getContext, onDestroy, onMount } from "svelte";
+  import type { ZipTestStore } from "./store";
+  import type { EntryHash } from "@holochain/client";
+  import "@shoelace-style/shoelace/dist/components/skeleton/skeleton.js";
+
+  const dispatch = createEventDispatcher();
+  const { getStore }: any = getContext("store");
+  let store: ZipTestStore = getStore();
+
+  export let bunchHash: EntryHash;
+  export let bunch: string;
+
+    type Moment = {
+        count: number,
+        date: Date,
+    }
+
+  let bunchRecord
+  let bunchContent
+
+  const GRAPH_HEIGHT = 200
+  let start
+  let unit = 10
+  let expected = 0
+  let moments = []
+  let allFound = false
+  let seconds = 0
+
+  let interval
+  onMount(async ()=>{
+    bunchRecord = await store.client.getThing(bunchHash)
+    bunchContent = JSON.parse(bunchRecord.entry.content)
+    start = new Date
+    expected = bunchContent.count*bunchContent.reps
+    unit = GRAPH_HEIGHT/expected
+    interval = setInterval(async () => {
+        const things = await store.client.getThings(bunch)
+        const count  = things.length
+        moments.push(count)
+        moments = moments
+        if (expected == count) {
+            allFound=true
+            clearInterval(interval)
+            interval = undefined
+        }
+        seconds +=1 
+    }, 1000);
+  })
+  onDestroy(()=>{
+    if (interval) {
+        clearInterval(interval)
+    }
+  })
+</script>
+
+<div class="wrapper">
+  {#if bunchRecord}
+    <div class="bunch-content">
+        {#if allFound}
+            All {expected} things found after {seconds} seconds.
+        {:else}
+            Seconds elapsed: : {seconds}
+        {/if}
+      <div>
+        Start: {start}
+      </div>
+      <div class="graph">
+        <div class="units" style={`height:${GRAPH_HEIGHT+40}px`}><span>{expected}</span></div>
+        {#each moments as moment,i}
+            <div style="display:flex;flex-direction:column;align-items:center">
+                <span style="font-size:80%;padding-left:3px;padding-right:3px">{moment}</span>
+                <div title={moment} class="bar" style={`height:${moment*unit}px;width:5px`}></div>
+                <span style="font-size:80%;padding-left:3px;padding-right:3px">{i}</span>
+
+            </div>
+        {/each}
+        <div class="units" style={`height:${GRAPH_HEIGHT+40}px`}><span>{expected}</span></div>
+        </div>
+    </div>
+  {:else}
+    <sl-skeleton effect="pulse" style="height: 10px; width: 100%"></sl-skeleton>
+  {/if}
+</div>
+
+<style>
+  .graph{
+    display: flex;
+    align-items: end;
+  }
+  .bar {
+    background-color: red;
+    justify-content: flex-end;
+  }
+  .units {
+    display: flex;
+    flex-direction: column;
+    justify-content: space-between;
+    align-items: right;
+  }
+  .wrapper {
+    padding-left: 10px;
+    width: 100%;
+    border-radius: 50%;
+    display: flex;
+    flex-direction: row;
+    justify-content: space-between;
+    align-items: center;
+  }
+  .bunch-content {
+    font-size: 16px;
+    font-weight: bold;
+    margin-right: 10px;
+  }
+</style>
diff --git a/ui/src/Controller.svelte b/ui/src/Controller.svelte
index ab31a3e..b90bee2 100644
--- a/ui/src/Controller.svelte
+++ b/ui/src/Controller.svelte
@@ -387,6 +387,7 @@
   }
   .test-type {
     padding: 5px;
+    border: solid 1px darkgray;
     cursor: pointer;
   }
   .test-type:hover, .selected {
diff --git a/ui/src/ControllerStream.svelte b/ui/src/ControllerStream.svelte
index c5411b3..1a715ad 100644
--- a/ui/src/ControllerStream.svelte
+++ b/ui/src/ControllerStream.svelte
@@ -11,7 +11,6 @@
   import type { WeaveClient } from "@lightningrodlabs/we-applet";
   import StreamPane from "./StreamPane.svelte";
   import type { EntryRecord } from "@holochain-open-dev/utils";
-  import { mdiAlertPlusOutline } from "@mdi/js";
 
   export let roleName = "";
   export let client: AppClient;
diff --git a/ui/src/ThingsPane.svelte b/ui/src/ThingsPane.svelte
index f8fb9ce..88dc3da 100644
--- a/ui/src/ThingsPane.svelte
+++ b/ui/src/ThingsPane.svelte
@@ -1,85 +1,160 @@
 <script lang="ts">
   import "@shoelace-style/shoelace/dist/components/button/button.js";
-  import { getContext } from "svelte";
+  import { getContext, onDestroy, onMount } from "svelte";
   import SvgIcon from "./SvgIcon.svelte";
   import type { ZipTestStore } from "./store";
   import { ThingStore } from "./thingStore";
+  import { get } from "svelte/store";
+  import Bunch from "./Bunch.svelte";
+  import "@shoelace-style/shoelace/dist/components/skeleton/skeleton.js";
 
   const { getStore }: any = getContext("store");
   const store: ZipTestStore = getStore();
 
-  const thingStore: ThingStore = new ThingStore(store.client)
+  let bunches
 
-  $: things = thingStore.thingLinks
+  let bunch: string = ""
 
-  const createThing = async () => {
-    let count = parseInt(inputCountElement.value)
-    let delay = parseInt(inputDelayElement.value)
+  let interval
+  onMount(()=>{
+    interval = setInterval(async () => {
+        const b = await store.client.getThings("bunches")
+        if (!bunches || b.length != bunches.length) {
+          bunches = b
+        }
+    }, 3000);
+  })
+  onDestroy(()=>{
+    if (interval) {
+        clearInterval(interval)
+    }
+  })
+  
+  const createBunch = async () => {
+    const profile = get(store.profilesStore.myProfile)
+    const name = (profile.status=="complete") ? profile.value.entry.nickname : "unknown"
+    bunch = `${name}.${new Date().getTime()}`
+    inputElement.value = bunch
+    let reps = parseInt(inputRepsElement.value);
+    let count = parseInt(inputCountElement.value);
+    let delay = parseInt(inputDelayElement.value);
+    await store.client.createThing("bunches",undefined, JSON.stringify({reps,count,delay}), bunch);
+    await createThings()
+  };
+
+  const createThings = async () => {
+    let count = parseInt(inputCountElement.value);
+    let reps = parseInt(inputRepsElement.value);
+    let delay = parseInt(inputDelayElement.value);
     setTimeout(() => {
-      _createThing(inputCountElement.value)
-      count-=1
-      inputCountElement.value = `${count}`
-      if (count>0) {
-        createThing()
+      _createThing(inputCountElement.value,reps);
+      count -= 1;
+      inputCountElement.value = `${count}`;
+      if (count > 0) {
+        createThings();
       }
     }, delay);
-  }
-  const _createThing = async (text) => {
-    await store.client.createThing(text);
+  };
+  const _createThing = async (text, reps) => {
+    await store.client.createThing(bunch, reps, text, undefined);
   };
 
-  let inputCountElement
-  let inputDelayElement
-  let disabled = false
+  function tag2Bunch(array) {
+  var result = "";
+  for (var i = 0; i < array.length; i++) {
+    result += String.fromCharCode(array[i]);
+  }
+  return result;
+}
 
+  const bunch2BunchName = (bunch) => {
+    return `${new Date(parseInt(bunch.split(".")[1]))}`
+  }
 
+  let inputElement;
+  let inputRepsElement;
+  let inputCountElement;
+  let inputDelayElement;
+  let disabled = false;
+  let activeBunch = ""
 </script>
-  {#if $things.status == "complete" }
-    <div class="wrapper">
-      <div class="send-controls">
-        <sl-input
-          style="width:60px"
-          value=1
-          bind:this={inputCountElement}
-          label="Count"
-        ></sl-input>
-        <sl-input
-          style="width:60px"
-          value={500}
-          bind:this={inputDelayElement}
-          label="Delay"
-        ></sl-input>
-    
-        <sl-button
-          style="margin-left:10px;"
-          circle
-          {disabled}
-          on:click={()=>createThing()}
-          ><SvgIcon icon="ziptest" size="20" />
-        </sl-button>
-      </div>
-      <div class="header">
-        Thing Count: {$things.value.length}
-      </div>
+
+  <div class="wrapper">
+    <div class="send-controls">
+      <sl-input
+        style="width:60px"
+        value="1"
+        bind:this={inputRepsElement}
+        label="Reps"
+      ></sl-input>
+      <sl-input
+        style="width:60px"
+        value="1"
+        bind:this={inputCountElement}
+        label="Count"
+      ></sl-input>
+      <sl-input
+        style="width:60px"
+        value={500}
+        bind:this={inputDelayElement}
+        label="Delay"
+      ></sl-input>
+      <sl-input
+        style="width:300px"
+        bind:this={inputElement}
+        on:sl-input={(e) => (disabled = !e.target.value || !inputElement.value)}
+        label="Message"
+      ></sl-input>
+
+      <sl-button
+        style="margin-left:10px;"
+        circle
+        {disabled}
+        on:click={() => createBunch()}
+        ><SvgIcon icon="ziptest" size="20" />
+      </sl-button>
+    </div>
+    <div class="header">
+      Bunches Count: {bunches ? bunches.length: "?"}
     </div>
-  {/if}
 
+    {#if !bunches}
+    <sl-skeleton effect="pulse" style="height: 10px; width: 100px;"></sl-skeleton>
+    {:else}
+    
+    <div class="bunches">
+      {#each bunches as link}
+      {@const bunch = tag2Bunch(link.tag)}
+      <div on:click={()=>{
+        if (bunch != activeBunch) {
+          activeBunch = bunch
+        }
+        else {
+          activeBunch = ''
+        }
+        }}>{bunch2BunchName(bunch)}</div>
+        {#if bunch == activeBunch}
+          <Bunch bunchHash={link.target} bunch={bunch}></Bunch>
+        {/if}
+      {/each}
+    </div>
+    {/if}
+  </div>
 
 <style>
   .wrapper {
     padding-left: 10px;
     display: flex;
     flex-direction: column;
-  
+
     width: 100%;
   }
-  .things {
+  .bunches {
     width: 100%;
     display: flex;
     flex: auto;
     flex-direction: column;
     overflow-y: auto;
-    height: 500px;
   }
   .thing {
     position: relative;
diff --git a/ui/src/store.ts b/ui/src/store.ts
index 38c6a94..3c80db7 100644
--- a/ui/src/store.ts
+++ b/ui/src/store.ts
@@ -23,22 +23,20 @@ import type { UnsubscribeFunction } from 'emittery';
 import { type Message, Stream, type Payload } from './stream';
 import {time} from "./util"
 import { derived } from 'svelte/store';
+import type { Thing } from './thingStore';
 
 
 TimeAgo.addDefaultLocale(en)
 
 const ZOME_NAME = 'ziptest'
 
-export type Thing = 
-{
-    content: string
-}
-export type ThingData = 
-{
-    originalHash: ActionHash,
-    content: string,
-    record: EntryRecord<Thing>,
+export type CreateThingInput = {
+    thing: Thing,
+    bunch: string,
+    reps: number,
+    tag: string| undefined,
 }
+
 export type EntryTypes = string
   | ({ type: 'Thing' } & Thing);
 
@@ -58,8 +56,16 @@ export class ZipTestClient extends ZomeClient<ZipTestSignal> {
         })
     }
 
-    async createThing(content) : Promise<EntryRecord<Thing>> {
-        return new EntryRecord(await this.callZome('create_thing', {content}))
+    async createThing(bunch:string, reps:number, content:string, tag:string| undefined) : Promise<EntryRecord<Thing>> {
+        console.log("CREATING THING", content)
+        
+        const input: CreateThingInput = {
+            thing: {content},
+            reps,
+            bunch,
+            tag
+        }
+        return new EntryRecord(await this.callZome('create_thing', input))
     }
     async updateThing(origHash: ActionHash, prevHash:ActionHash, content: string) : Promise<EntryRecord<Thing>> {
         return new EntryRecord(await this.callZome('update_thing', {
@@ -67,8 +73,8 @@ export class ZipTestClient extends ZomeClient<ZipTestSignal> {
             previous_thing_hash: prevHash,
             updated_thing: {content}}))
     }
-    async getThings() : Promise<Link[]> {
-        const results = await this.callZome('get_things', undefined)
+    async getThings(bunch: string) : Promise<Link[]> {
+        const results = await this.callZome('get_things', bunch)
         return results
     }
     async getThing(hash: ActionHash) : Promise<EntryRecord<Thing>| undefined> {
@@ -94,20 +100,6 @@ export class ZipTestStore {
     timeAgo = new TimeAgo('en-US')
     updating = false
     client: ZipTestClient;
-    thingLinks: AsyncReadable<Link[]>
-    thingHashes: AsyncReadable<ActionHash[]>
-    things: LazyHoloHashMap<ActionHash,AsyncReadable<ThingData>> = new LazyHoloHashMap(
-        (hash: ActionHash) => {
-            const latestVersion = latestVersionOfEntryStore(this.client, () =>
-                this.client.getThing(hash)
-            );
-            const asyncThing = pipe(latestVersion,
-                record => record.entry.content
-                )
-            return pipe(joinAsync([asyncThing, latestVersion]), ([content, record]) => {return {originalHash: hash, content,record}})
-        }
-    )
-    thingsList: AsyncReadable<ThingData[]>
     uiProps: Writable<UIProps> 
     unsub: Unsubscriber
     dnaHash: DnaHash
@@ -247,18 +239,6 @@ export class ZipTestStore {
           })
         this.myAgentPubKeyB64 = encodeHashToBase64(this.myAgentPubKey);
 
-        this.thingLinks = collectionStore(
-            this.client,
-            () => this.client.getThings(),
-            'AllThings'
-          );
-        this.thingHashes = asyncDerived(this.thingLinks,
-            links=> links.map(link=>link.target)
-        )
-        this.thingsList = pipe(this.thingHashes, 
-            hashes=> sliceAndJoin(this.things,hashes),
-            map=>Array.from(map.values())
-        )
 
         this.uiProps = writable({
             tips: new HoloHashMap,
@@ -297,8 +277,4 @@ export class ZipTestStore {
         return this.client.client.myPubKey;
     }
 
-    async makeThing(content: string) : Promise<any> {
-        return await this.client.createThing(content)
-    }
-
 }
\ No newline at end of file
diff --git a/ui/src/thingStore.ts b/ui/src/thingStore.ts
index 82f8476..70c4be2 100644
--- a/ui/src/thingStore.ts
+++ b/ui/src/thingStore.ts
@@ -38,10 +38,14 @@ export class ThingStore {
     });
   thingsList: AsyncReadable<ThingData[]>;
 
+  async createBunch(bunch:string, content:string) {
+    await this.client.createThing("bunches",undefined, content, bunch);
+  }
+
   constructor(public client: ZipTestClient) {
     this.thingLinks = collectionStore(
       this.client,
-      () => this.client.getThings(),
+      () => this.client.getThings("bunches"),
       "AllThings",
       1000
     );