contacts-pane 2.6.4-ffd7d417 → 2.6.5-alpha

package/contactLogic.js

@@ -138,7 +138,7 @@ export async function addPersonToGroup (thing, group) {
   const pname = kb.any(thing, ns.vcard('fn'))
   const gname = kb.any(group, ns.vcard('fn'))
   if (!pname) { return alert('No vcard name known for ' + thing) }
-  const already = kb.holds(group, ns.vcard('hasMember'), thing, group.doc())
+  const already = kb.holds(thing, ns.vcard('fn'), null, group.doc())
   if (already) {
     return alert(
       'ALREADY added ' + pname + ' to group ' + gname
@@ -147,14 +147,18 @@ export async function addPersonToGroup (thing, group) {
   const message = 'Add ' + pname + ' to group ' + gname + '?'
   if (!confirm(message)) return
   const ins = [
-    $rdf.st(group, ns.vcard('hasMember'), thing, group.doc()),
     $rdf.st(thing, ns.vcard('fn'), pname, group.doc())
   ]
-  // find person webIDs
+  // find person webIDs and insert in vcard:hasMember
   const webIDs = getPersonas(kb, thing).map(webid => webid.value)
-  webIDs.forEach(webid => {
-    ins.push($rdf.st(thing, ns.owl('sameAs'), kb.sym(webid), group.doc()))
-  })
+  if (webIDs.length) {
+    webIDs.forEach(webid => {
+      ins.push($rdf.st(kb.sym(webid), ns.owl('sameAs'), thing, group.doc()))
+      ins.push($rdf.st(group, ns.vcard('hasMember'), kb.sym(webid), group.doc()))
+    })
+  } else {
+    ins.push($rdf.st(group, ns.vcard('hasMember'), thing, group.doc()))
+  }
   try {
     await updater.update([], ins)
     // to allow refresh of card groupList
@@ -165,3 +169,28 @@ export async function addPersonToGroup (thing, group) {
   }
   return thing
 }
+
+/**
+ * Find persons member of a group
+ */
+
+export function groupMembers (kb, group) {
+  const a = kb.each(group, ns.vcard('hasMember'), null, group.doc())
+  let b = []
+  a.forEach(item => {
+    /* const contacts = kb.each(item, ns.owl('sameAs'), null, group.doc())
+    if (contacts.length) {
+      if (!kb.any(contacts[0], ns.vard('fn'))) b = b.concat(item) // this is the old data model
+      else b = b.concat(contacts)
+    } else { b = b.concat(item) }
+    b = b.concat(item) */
+
+    // to keep compatibility with old data model
+    // check if item is a contact, else it is a WebID and parse 'sameAs' for contacts
+    b = kb.any(item, ns.vcard('fn'), null, group.doc()) ? b.concat(item) : b.concat(kb.each(item, ns.owl('sameAs'), null, group.doc()))
+  })
+  const strings = new Set(b.map(contact => contact.uri)) // remove dups
+  b = [...strings].map(uri => kb.sym(uri))
+  return b
+}
+

package/contactsPane.js

@@ -15,11 +15,12 @@ to change its state according to an ontology, comment on it, etc.
 /* global alert, confirm */
 
 import { authn } from 'solid-logic'
-import { addPersonToGroup, saveNewContact, saveNewGroup } from './contactLogic'
+import { addPersonToGroup, saveNewContact, saveNewGroup, groupMembers } from './contactLogic'
 import * as UI from 'solid-ui'
 import { mintNewAddressBook } from './mintNewAddressBook'
 import { renderIndividual } from './individual'
 import { toolsPane } from './toolsPane'
+import { groupMembership } from './groupMembershipControl'
 
 // const $rdf = UI.rdf
 const ns = UI.ns
@@ -217,8 +218,25 @@ export default {
                   const nameEmailIndex = kb.any(book, ns.vcard('nameEmailIndex'))
                   await kb.fetcher.load(nameEmailIndex)
 
+                  //  - delete person's WebID's in each Group
                   //  - delete the references to it in group files and save them back
-                  //   - delete the reference in people.ttl and save it back
+                  //  - delete the reference in people.ttl and save it back
+
+                  // find all Groups
+                  const groups = groupMembership(person)
+                  let removeFromGroups = []
+                  // find person WebID's
+                  groups.map( group => {
+                    const webids = kb.each(null, ns.owl('sameAs'), person, group.doc())
+                    // for each check in each Group that it is not used by an other person then delete
+                    webids.map( webid => {
+                      if (kb.statementsMatching(webid, ns.owl('sameAs'), null, group.doc()).length = 1) {
+                        removeFromGroups = removeFromGroups.concat(kb.statementsMatching(group, ns.vcard('hasMember'), webid, group.doc()))
+                      }
+                    })
+                  })
+                  // console.log(removeFromGroups)
+                  await kb.updater.updateMany(removeFromGroups)
                   await deleteThingAndDoc(person)
                   await deleteRecursive(kb, container)
                   refreshNames() // "Doesn't work" -- maybe does now with waiting for async
@@ -417,8 +435,7 @@ export default {
           const groups = Object.keys(selectedGroups).map(groupURI => kb.sym(groupURI))
           groups.forEach(group => {
             if (selectedGroups[group.value]) {
-              const a = kb.each(group, ns.vcard('hasMember'), null, group.doc())
-              cards = cards.concat(a)
+              cards = cards.concat(groupMembers(kb, group))
             }
           })
           cards.sort(compareForSort) // @@ sort by name not UID later
@@ -578,8 +595,42 @@ export default {
           const groups = groupsInOrder()
           utils.syncTableToArrayReOrdered(groupsMainTable, groups, renderGroupRow)
           refreshGroupsSelected()
+          checkDataModel(groups)
         } // syncGroupTable
 
+        async function checkDataModel(groups) {
+          // check if migration is needed in groups
+          async function updateDataModel(groups) {
+            let ds = []
+            let ins = []
+            groups.forEach(group => {
+              let vcardOrWebids = kb.statementsMatching(null, ns.owl('sameAs'), null, group.doc()).map(st => st.subject)
+              const strings = new Set(vcardOrWebids.map(contact => contact.uri)) // remove dups
+              vcardOrWebids = [...strings].map(uri => kb.sym(uri))
+              vcardOrWebids.forEach(item => {
+                if (kb.each(item, ns.vcard('fn'), null, group.doc()).length) {
+                  // delete item, it is an old data model,  item is a card not a webid.
+                  ds = ds.concat(kb
+                    .statementsMatching(item, ns.owl('sameAs'), null, group.doc())
+                    .concat(kb.statementsMatching(undefined, undefined, item, group.doc())))
+                  // add card webids to group
+                  const webids = kb.each(item, ns.owl('sameAs'), null, group.doc())
+                  webids.forEach(webid => {
+                    ins = ins.concat($rdf.st(webid, ns.owl('sameAs'), item, group.doc()))
+                      .concat($rdf.st(group, ns.vcard('hasMember'), webid, group.doc()))
+                  })
+                }
+              })
+            })
+            if (ds.length && confirm('Groups data model need to be updated ?')) {
+              await kb.updater.updateMany(ds, ins)
+              alert('Update done')
+            }
+          }
+          await kb.fetcher.load(groups)
+          updateDataModel(groups)
+        } // checkDataModel
+
         // Click on New Group button
         async function newGroupClickHandler (_event) {
           cardMain.innerHTML = ''

package/groupMembershipControl.js

@@ -1,6 +1,7 @@
 
 // Render a control to record the group memberships we have for this agent
 import * as UI from 'solid-ui'
+import { store } from 'solid-logic'
 
 // const $rdf = UI.rdf
 const ns = UI.ns
@@ -8,25 +9,33 @@ const ns = UI.ns
 // const widgets = UI.widgets
 const utils = UI.utils
 // const style = UI.style
+const kb = store
 
 // Groups the person is a member of
+export function groupMembership (person) {
+  let groups = kb.statementsMatching(null, ns.owl('sameAs'), person).map(st => st.why)
+    .concat(kb.each(null, ns.vcard('hasMember'), person))
+  const strings = new Set(groups.map(group => group.uri)) // remove dups
+  groups = [...strings].map(uri => kb.sym(uri))
+  return groups
+}
+
 export async function renderGroupMemberships (person, context) {
   // Remove a person from a group
   async function removeFromGroup (thing, group) {
     const pname = kb.any(thing, ns.vcard('fn'))
     const gname = kb.any(group, ns.vcard('fn'))
-    // find all webids of thing
+    // find all WebIDs of thing
     const thingwebids = kb.each(null, ns.owl('sameAs'), thing, group.doc())
-    // webid can be deleted only if not used in a other thing
+    // WebID can be deleted only if not used in another thing
     let webids = []
     thingwebids.map(webid => {
-      if (kb.any(webid, ns.owl('sameAs'), thing, group.doc()).length = 1 ) webids = webids.concat(webid)
+      if (kb.statementsMatching(webid, ns.owl('sameAs'), thing, group.doc())) webids = webids.concat(webid)
       }
     )
-    // const webids = kb.any(webid, ns.owl('sameAs'))
     let thingOrWebid = thing
-    if (webids.length > 0) thingOrWebid = kb.sym(webids[0])
-    const groups = kb.each(null, ns.vcard('hasMember'), thingOrWebid)
+    if (webids.length > 0) thingOrWebid = webids[0]
+    const groups = kb.each(null, ns.vcard('hasMember'), thingOrWebid) // in all groups a person has same structure
     if (groups.length < 2) {
       alert(
         'Must be a member of at least one group.  Add to another group first.'
@@ -38,7 +47,11 @@ export async function renderGroupMemberships (person, context) {
       let del = kb
         .statementsMatching(person, undefined, undefined, group.doc())
         .concat(kb.statementsMatching(undefined, undefined, person, group.doc()))
-      webids.map(webid => del.concat(kb.statementsMatching(undefined,undefined, webid, group.doc())))
+      webids.map(webid => {
+        if (kb.statementsMatching(webid, ns.owl('sameAs'), undefined, group.doc()).length < 2) {
+         del = del.concat(kb.statementsMatching(undefined, undefined, webid, group.doc()))
+        }
+      })
       kb.updater.update(del, [], function (uri, ok, err) {
         if (!ok) {
           const message = 'Error removing member from group ' + group + ': ' + err
@@ -64,12 +77,10 @@ export async function renderGroupMemberships (person, context) {
     return tr
   }
 
-  // find all documents where person ns.vcard('fn')
+  // find all groups where person has membership
   function syncGroupList () {
-    // to be changed person and or webids
-    // const groups = kb.each(null, ns.vcard('hasMember'), person)
-    const groups = kb.each(person, ns.vcard('fn'), undefined) // non il faut acceder a la liste des group.doc()
-    utils.syncTableToArray(groupList, groups, newRowForGroup)
+    // person and/or WebIDs to be changed
+    utils.syncTableToArray(groupList, groupMembership(person), newRowForGroup)
   }
 
   async function loadGroupsFromBook (book = null) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "contacts-pane",
-  "version": "2.6.4-ffd7d417",
+  "version": "2.6.5-alpha",
   "description": "Contacts Pane: Contacts manager for Address Book, Groups, and Individuals.",
   "main": "./contactsPane.js",
   "scripts": {
@@ -10,8 +10,8 @@
     "lint": "eslint '*.js'",
     "lint-fix": "eslint '*.js' --fix",
     "test": "npm run lint",
-    "ignore:prepublishOnly": "npm test && npm run build",
-    "ignore:postpublish": "git push origin main --follow-tags"
+    "prepublishOnly": "npm test && npm run build",
+    "postpublish": "git push origin main --follow-tags"
   },
   "repository": {
     "type": "git",

package/toolsPane.js

@@ -4,7 +4,7 @@
 
 import * as UI from 'solid-ui'
 import { store } from 'solid-logic'
-import { saveNewGroup, addPersonToGroup } from './contactLogic'
+import { saveNewGroup, addPersonToGroup, groupMembers } from './contactLogic'
 export function toolsPane (
   selectAllGroups,
   selectedGroups,
@@ -85,7 +85,9 @@ export function toolsPane (
     function stats () {
       const totalCards = kb.each(undefined, VCARD('inAddressBook'), book).length
       log('' + totalCards + ' cards loaded. ')
-      const groups = kb.each(book, VCARD('includesGroup'))
+      let groups = kb.each(book, VCARD('includesGroup'))
+      const strings = new Set(groups.map(group => group.uri)) // remove dups
+      groups = [...strings].map(uri => kb.sym(uri))
       log('' + groups.length + ' total groups. ')
       const gg = []
       for (const g in selectedGroups) {
@@ -137,7 +139,7 @@ export function toolsPane (
 
       for (let i = 0; i < gg.length; i++) {
         const g = kb.sym(gg[i])
-        const a = kb.each(g, ns.vcard('hasMember'))
+        const a = groupMembers(kb, g)
         log(UI.utils.label(g) + ': ' + a.length + ' members')
         for (let j = 0; j < a.length; j++) {
           const card = a[j]
@@ -357,6 +359,7 @@ export function toolsPane (
                   const other = stats.nameLessIndex[cardText]
                   if (other) {
                     log('  Matches with ' + other)
+                    // alain not sure it works we may need to concat with 'sameAs' group.doc (.map(st => st.why))
                     const cardGroups = kb.each(null, ns.vcard('hasMember'), card)
                     const otherGroups = kb.each(null, ns.vcard('hasMember'), other)
                     for (let j = 0; j < cardGroups.length; j++) {
@@ -432,9 +435,9 @@ export function toolsPane (
               for (let i = 0; i < stats.uniques.length; i++) {
                 stats.uniquesSet[stats.uniques[i].uri] = true
               }
-              stats.groupMembers = kb
-                .statementsMatching(null, ns.vcard('hasMember'))
-                .map(st => st.object)
+              stats.groupMembers = []
+              kb.each(null, ns.vcard('hasMember'))
+                .map(group => { stats.groupMembers = stats.groupMembers.concat(groupMembers(kb, group)) })
               log('  Naive group members ' + stats.groupMembers.length)
               stats.groupMemberSet = []
               for (let j = 0; j < stats.groupMembers.length; j++) {
@@ -575,7 +578,10 @@ export function toolsPane (
                 log('   Regenerating group of uniques...' + cleanGroup)
                 const data = sz.statementsToN3(sts)
 
-                return kb.fetcher.webOperation('PUT', cleanGroup, { data })
+                return kb.fetcher.webOperation('PUT', cleanGroup, {
+                  data: data,
+                  contentType: 'text/turtle'
+                })
               })
               .then(() => {
                 log('     Done uniques group ' + cleanGroup)
@@ -615,12 +621,14 @@ export function toolsPane (
             .then(scanForDuplicates)
             .then(checkGroupMembers)
             .then(checkAllNameless)
-            .then((resolve, reject) => {
-              if (confirm('Write new clean versions?')) {
-                resolve(true)
-              } else {
-                reject()
-              }
+            .then(() => {
+              return new Promise(function (resolve, reject) {
+                if (confirm('Write new clean versions?')) {
+                  resolve(true)
+                } else {
+                  reject()
+                }
+              })
             })
             .then(saveCleanPeople)
             .then(saveAllGroups)
@@ -660,13 +668,15 @@ export function toolsPane (
 
       const reverseIndex = {}
       const groupless = []
-      const groups = kb.each(book, VCARD('includesGroup'))
-
+      let groups = kb.each(book, VCARD('includesGroup'))
+      const strings = new Set(groups.map(group => group.uri)) // remove dups
+      groups = [...strings].map(uri => kb.sym(uri))
       log('' + groups.length + ' total groups. ')
 
       for (let i = 0; i < groups.length; i++) {
         const g = groups[i]
-        const a = kb.each(g, ns.vcard('hasMember'))
+        const a = groupMembers(kb, g)
+
         log(UI.utils.label(g) + ': ' + a.length + ' members')
         for (let j = 0; j < a.length; j++) {
           kb.allAliases(a[j]).forEach(function (y) {
@@ -714,6 +724,46 @@ export function toolsPane (
     fixGrouplessButton.style.cssText = buttonStyle
     fixGrouplessButton.textContent = 'Put all individuals with no group in a new group'
     fixGrouplessButton.addEventListener('click', _event => fixGroupless(book))
+
+    async function fixToOldDataModel (book) {
+      async function updateToOldDataModel(groups) {
+        let ds = []
+        let ins = []
+        groups.forEach(group => {
+          let vcardOrWebids = kb.statementsMatching(null, ns.owl('sameAs'), null, group.doc()).map(st => st.subject)
+          const strings = new Set(vcardOrWebids.map(contact => contact.uri)) // remove dups
+          vcardOrWebids = [...strings].map(uri => kb.sym(uri))
+          vcardOrWebids.forEach(item => {
+            if (!kb.each(item, ns.vcard('fn'), null, group.doc()).length) {
+              // delete item this is a new data model,  item is a webid not a card.
+              ds = ds.concat(kb
+                .statementsMatching(item, ns.owl('sameAs'), null, group.doc())
+                .concat(kb.statementsMatching(undefined, undefined, item, group.doc())))
+              // add webid card to group
+              const cards = kb.each(item, ns.owl('sameAs'), null, group.doc())
+              cards.forEach(card => {
+                ins = ins.concat($rdf.st(card, ns.owl('sameAs'), item, group.doc()))
+                  .concat($rdf.st(group, ns.vcard('hasMember'), card, group.doc()))
+              })
+            }
+          })
+        })
+        if (ds.length && confirm('Groups can be updated to old data model ?')) {
+          await kb.updater.updateMany(ds, ins)
+          alert('Update done')
+        } else { if (!ds.length) alert('Nothing to update.\nAll Groups already use the old data model.')}
+      }
+      let groups = kb.each(book, VCARD('includesGroup'))
+      const strings = new Set(groups.map(group => group.uri)) // remove dups
+      groups = [...strings].map(uri => kb.sym(uri))
+      updateToOldDataModel(groups)
+    }
+
+    const fixToOldDataModelButton = pane.appendChild(dom.createElement('button'))
+    fixToOldDataModelButton.style.cssText = buttonStyle
+    fixToOldDataModelButton.textContent = 'Revert groups to old data model'
+    fixToOldDataModelButton.addEventListener('click', _event => fixToOldDataModel(book))
+
   } // main
   main()
   return pane

package/webidControl.js

@@ -51,15 +51,15 @@ export async function addWebIDToContacts (person, webid, urlType, kb) {
     $rdf.st(vcardURLThing, ns.rdf('type'), urlType, person.doc()),
     $rdf.st(vcardURLThing, ns.vcard('value'), webid, person.doc())
   ]
-  // insert webID in groups
-  // replace person with webId in vcard:hasMember (webId may already exist)
+  // insert WebID in groups
+  // replace person with WebID in vcard:hasMember (WebID may already exist)
   // insert owl:sameAs
   const groups = kb.each(null, ns.vcard('hasMember'), person)
-  const deletables = []
+  let deletables = []
   groups.forEach(group => {
-    deletables.push($rdf.st(group, ns.vcard('hasMember'), person, group.doc()))
-    insertables.push($rdf.st(group, ns.vcard('hasMember'), kb.sym(webid), group.doc())) // may exist do we need to check ?
-    insertables.push($rdf.st(person, ns.owl('sameAs'), kb.sym(webid), group.doc()))
+    deletables = deletables.concat(kb.statementsMatching(group, ns.vcard('hasMember'), person, group.doc()))
+    insertables.push($rdf.st(group, ns.vcard('hasMember'), kb.sym(webid), group.doc())) // May exist; do we need to check?
+    insertables.push($rdf.st(kb.sym(webid), ns.owl('sameAs'), person, group.doc()))
   })
   try {
     await updateMany(deletables, insertables)
@@ -86,13 +86,13 @@ export async function removeWebIDFromContacts (person, webid, urlType, kb) {
 
   // remove webIDs from groups
   const groups = kb.each(null, ns.vcard('hasMember'), kb.sym(webid))
-  const removeFromGroups = []
+  let removeFromGroups = []
   const insertInGroups = []
-  groups.forEach(group => {
-    removeFromGroups.push($rdf.st(person, ns.owl('sameAs'), kb.sym(webid), group.doc()))
-    if (kb.each(null, ns.owl('sameAs'), kb.sym(webid), group.doc()).length = 1) {
-      removeFromGroups.push($rdf.st(group, ns.vcard('hasMember'), kb.sym(webid)), group.doc())
-      insertInGroups.push($rdf.st(group, ns.vcard('hasMember'), person, group.doc()))
+  groups.forEach(async group => {
+    removeFromGroups = removeFromGroups.concat(kb.statementsMatching(kb.sym(webid), ns.owl('sameAs'), person, group.doc()))
+    insertInGroups.push($rdf.st(group, ns.vcard('hasMember'), person, group.doc()))
+    if (kb.statementsMatching(kb.sym(webid), ns.owl('sameAs'), null, group.doc()).length < 2) {
+      removeFromGroups = removeFromGroups.concat(kb.statementsMatching(group, ns.vcard('hasMember'), kb.sym(webid), group.doc()))
     }
   })
   await updateMany(removeFromGroups, insertInGroups)