Skip to content

P
purescript-gargantext
Commit 7a9fdad7 authored by arturo's avatar arturo
Browse files
Options

>>> continue

parent 8e4975ab
Pipeline #2016 failed with stage
    Expand all Hide whitespace changes
    Inline Side-by-side
    Showing with 595 additions and 212 deletions
    src/Gargantext/Components/Nodes/Corpus/Phylo.purs
    View file @ 7a9fdad7
    ......@@ -12,8 +12,9 @@ import Data.HTTP.Method (Method(..))
    import Data.Maybe (Maybe(..))
    import Effect.Aff (Aff, launchAff_)
    import Effect.Class (liftEffect)
    import Gargantext.Components.PhyloExplorer.JSON (PhyloJSONSet)
    import Gargantext.Components.PhyloExplorer.Layout (layout)
    import Gargantext.Components.PhyloExplorer.Types (PhyloDataset)
    import Gargantext.Components.PhyloExplorer.Types (PhyloDataSet)
    import Gargantext.Sessions (Session)
    import Gargantext.Types (NodeID)
    import Gargantext.Utils.Reactix as R2
    ......@@ -36,7 +37,7 @@ phyloLayoutCpt :: R.Component Props
    phyloLayoutCpt = here.component "phyloLayout" cpt where
    cpt _ _ = do
    fetchedDataBox <- T.useBox (Nothing :: Maybe PhyloDataset)
    fetchedDataBox <- T.useBox (Nothing :: Maybe PhyloJSONSet)
    fetchedData <- T.useLive T.unequal fetchedDataBox
    R.useEffectOnce' $ launchAff_ do
    ......@@ -47,10 +48,10 @@ phyloLayoutCpt = here.component "phyloLayout" cpt where
    pure case fetchedData of
    Nothing -> mempty
    Just phyloDataset -> layout { phyloDataset } []
    Just phyloDataSet -> layout { phyloDataSet } []
    fetchPhyloJSON :: Aff (Either String PhyloDataset)
    fetchPhyloJSON :: Aff (Either String PhyloDataSet)
    fetchPhyloJSON =
    let
    request = AX.defaultRequest
    ......@@ -65,4 +66,4 @@ fetchPhyloJSON =
    Left err -> pure $ Left $ AX.printError err
    Right response -> case JSON.readJSON response.body of
    Left err -> pure $ Left $ show err
    Right (res :: PhyloDataset) -> pure $ Right res
    Right (res :: PhyloJSONSet) -> pure $ Right $ parsePhyloJSONSet res
    src/Gargantext/Components/PhyloExplorer/JSON.purs 0 → 100644
    View file @ 7a9fdad7
    module Gargantext.Components.PhyloExplorer.JSON where
    import Gargantext.Prelude
    import Data.Generic.Rep (class Generic)
    import Data.Generic.Rep as GR
    import Data.Maybe (Maybe)
    import Data.Show.Generic (genericShow)
    import Gargantext.Utils.SimpleJSON (untaggedSumRep)
    import Simple.JSON as JSON
    type GraphData =
    ( bb :: String
    , color :: String
    , fontsize :: String
    , label :: String
    , labelloc :: String
    , lheight :: String
    , lp :: String
    , lwidth :: String
    , name :: String
    , nodesep :: String
    , overlap :: String
    , phyloBranches :: String
    , phyloDocs :: String
    , phyloFoundations :: String
    , phyloGroups :: String
    , phyloPeriods :: String
    , phyloSources :: String
    , phyloTerms :: String
    , phyloTimeScale :: String
    , rank :: String
    , ranksep :: String
    , ratio :: String
    , splines :: String
    , style :: String
    )
    --------------------------------------------------
    newtype PhyloJSONSet = PhyloJSONSet
    { _subgraph_cnt :: Int
    , directed :: Boolean
    , edges :: Array Edge
    , objects :: Array PhyloObject
    , strict :: Boolean
    | GraphData
    }
    derive instance Generic PhyloJSONSet _
    derive instance Eq PhyloJSONSet
    instance Show PhyloJSONSet where show = genericShow
    derive newtype instance JSON.ReadForeign PhyloJSONSet
    --------------------------------------------------
    type NodeData =
    ( height :: String
    , label :: String
    , name :: String
    , nodeType :: String
    , pos :: String
    , shape :: String
    , width :: String
    )
    data PhyloObject
    = Layer
    { _gvid :: Int
    , nodes :: Array Int
    | GraphData
    }
    | BranchToNode
    { _gvid :: Int
    , age :: String
    , bId :: String
    , birth :: String
    , branchId :: String
    , branch_x :: String
    , branch_y :: String
    , fillcolor :: String
    , fontname :: String
    , fontsize :: String
    , size :: String
    , style :: String
    | NodeData
    }
    | GroupToNode
    { _gvid :: Int
    , bId :: String
    , branchId :: String
    , fontname :: String
    , foundation :: String
    , frequence :: String
    , from :: String
    , lbl :: String
    , penwidth :: String
    , role :: String
    , seaLvl :: String
    , source :: String
    , strFrom :: Maybe String
    , strTo :: Maybe String
    , support :: String
    , to :: String
    , weight :: String
    | NodeData
    }
    | PeriodToNode
    { _gvid :: Int
    , fontsize :: String
    , from :: String
    , strFrom :: Maybe String
    , strTo :: Maybe String
    , to :: String
    | NodeData
    }
    derive instance Generic PhyloObject _
    derive instance Eq PhyloObject
    instance Show PhyloObject where show = genericShow
    instance JSON.ReadForeign PhyloObject where
    readImpl f = GR.to <$> untaggedSumRep f
    --------------------------------------------------
    type EdgeData =
    ( color :: String
    , head :: Int
    , pos :: String
    , tail :: Int
    , width :: String
    )
    data Edge
    = GroupToGroup
    { _gvid :: Int
    , constraint :: String
    , edgeType :: String
    , lbl :: String
    , penwidth :: String
    | EdgeData
    }
    | BranchToGroup
    { _gvid :: Int
    , arrowhead :: String
    , edgeType :: String
    | EdgeData
    }
    | BranchToBranch
    { _gvid :: Int
    , arrowhead :: String
    , style :: String
    | EdgeData
    }
    | GroupToAncestor
    { _gvid :: Int
    , arrowhead :: String
    , lbl :: String
    , penwidth :: String
    , style :: String
    | EdgeData
    }
    | PeriodToPeriod
    { _gvid :: Int
    | EdgeData
    }
    derive instance Generic Edge _
    derive instance Eq Edge
    instance Show Edge where show = genericShow
    instance JSON.ReadForeign Edge where
    readImpl f = GR.to <$> untaggedSumRep f
    src/Gargantext/Components/PhyloExplorer/Layout.purs
    View file @ 7a9fdad7
    ......@@ -4,12 +4,20 @@ module Gargantext.Components.PhyloExplorer.Layout
    import Gargantext.Prelude
    import DOM.Simple.Console (log2)
    import DOM.Simple (Window, window)
    import Data.Array as Array
    import Data.Int (fromString)
    import Data.Maybe (maybe)
    import Data.Date as Date
    import Data.FoldableWithIndex (forWithIndex_)
    import Data.Int as Int
    import Data.Maybe (Maybe(..), maybe)
    import Data.Number as Number
    import Data.String as String
    import Gargantext.Components.PhyloExplorer.Types (PhyloDataset(..))
    import Data.Traversable (for)
    import Data.Tuple as Tuple
    import Data.Tuple.Nested ((/\))
    import Effect (Effect)
    import FFI.Simple (maybeGetProperty, (..), (...))
    import Gargantext.Components.PhyloExplorer.Types (Group, PhyloDataSet(..))
    import Gargantext.Utils (nbsp)
    import Gargantext.Utils.Reactix as R2
    import Reactix as R
    ......@@ -20,40 +28,20 @@ here :: R2.Here
    here = R2.here "Gargantext.Components.PhyloExplorer"
    type Props =
    ( phyloDataset :: PhyloDataset
    ( phyloDataSet :: PhyloDataSet
    )
    layout :: R2.Component Props
    layout = R.createElement layoutCpt
    layoutCpt :: R.Component Props
    layoutCpt = here.component "layout" cpt where
    cpt { phyloDataset: (PhyloDataset phyloDataset)
    cpt { phyloDataSet: (PhyloDataSet o)
    } _ = do
    -- States
    let
    { phyloDocs
    , phyloBranches
    , phyloGroups
    , phyloTerms
    , phyloPeriods
    , phyloFoundations
    , phyloSources
    } = phyloDataset
    nbDocs = parseInt phyloDocs
    nbBranches = parseInt phyloBranches
    nbGroups = parseInt phyloGroups
    nbTerms = parseInt phyloTerms
    nbPeriods = parseInt phyloPeriods
    nbFoundations = parseInt phyloFoundations
    sourcesBox <- T.useBox (mempty :: Array String)
    sources <- T.useLive T.unequal sourcesBox
    -- Hooks
    R.useEffectOnce' $ do
    sources' <- pure $ stringArrToArr phyloSources
    T.write_ sources' sourcesBox
    pure unit
    -- @hightlightSource
    let
    ......@@ -126,7 +114,7 @@ layoutCpt = here.component "layout" cpt where
    [ H.text "unselect source ✕" ]
    ]
    <>
    flip Array.mapWithIndex sources
    flip Array.mapWithIndex o.sources
    ( \idx val ->
    H.option
    { value: idx }
    ......@@ -162,7 +150,10 @@ layoutCpt = here.component "layout" cpt where
    phyloCorpus {} []
    ,
    phyloCorpusInfo
    { nbDocs, nbFoundations, nbPeriods }
    { nbDocs : o.nbDocs
    , nbFoundations : o.nbFoundations
    , nbPeriods : o.nbPeriods
    }
    []
    ,
    -- H.div
    ......@@ -176,7 +167,10 @@ layoutCpt = here.component "layout" cpt where
    phyloPhyloInfo
    { nbTerms, nbGroups, nbBranches }
    { nbTerms : o.nbTerms
    , nbGroups : o.nbGroups
    , nbBranches : o.nbBranches
    }
    []
    ,
    ......@@ -261,15 +255,33 @@ layoutCpt = here.component "layout" cpt where
    ]
    parseInt :: String -> Int
    parseInt s = maybe 0 identity $ fromString s
    stringArrToArr :: String -> Array String
    stringArrToArr
    = String.replace (String.Pattern "[") (String.Replacement "")
    >>> String.replace (String.Pattern "]") (String.Replacement "")
    >>> String.split (String.Pattern ",")
    >>> Array.filter (\s -> not eq 0 $ String.length s)
    setGlobalDependencies :: Window -> PhyloDataSet -> Effect Unit
    setGlobalDependencies w (PhyloDataSet o)
    = do
    -- _ <- w ... "freq" $ {}
    -- _ <- w ... "nbBranches" $ o.nbBranches
    -- _ <- w ... "nbDocs" $ o.nbDocs
    -- _ <- w ... "nbFoundations" $ o.nbFoundations
    -- _ <- w ... "nbGroups" $ o.nbGroups
    -- _ <- w ... "nbPeriods" $ o.nbPeriods
    -- _ <- w ... "nbTerms" $ o.nbTerms
    -- _ <- w ... "sources" $ o.sources
    -- _ <- w ... "terms" $ {}
    -- _ <- w ... "timeScale" $ o.timeScale
    -- _ <- w ... "weighted" $ o.weighted
    (freq :: Array Int) <- pure $ w .. "freq"
    pure unit
    -- forWithIndex_ o.foundations $ \i _ -> case maybeGetProperty (show i) freq of
    -- Nothing -> freq ... (show i) $ 0
    -- Just v -> freq ... (show i) $ (v + 1)
    -- pure $ for o.groups \(g :: Group)-> pure unit
    --------------------------------------------------------
    ......
    src/Gargantext/Components/PhyloExplorer/layout.js → src/Gargantext/Components/PhyloExplorer/Types.js
    View file @ 7a9fdad7
    'use strict';
    function readJson(file, callback) {
    var raw = new XMLHttpRequest();
    raw.overrideMimeType("application/json");
    raw.open("GET", file, true);
    raw.onreadystatechange = function() {
    if (raw.readyState === 4 && raw.status == "200") {
    callback(raw.responseText);
    }
    }
    raw.send(null);
    }
    function unhide(mode) {
    document.querySelector("#reset").style.visibility = "visible";
    document.querySelector("#label").style.visibility = "visible";
    document.querySelector("#heading").style.visibility = "visible";
    if (mode != "static") {
    document.querySelector("#export").style.visibility = "visible";
    }
    }
    window.addEventListener("load", function() {
    // read the config
    readJson("./config.json",function(data1){
    var conf = JSON.parse(data1);
    // available config modes are "static" or "explorable"
    if (conf.mode == "static") {
    var path = "";
    var name = "";
    if (conf.path == null || conf.path == "") {
    path = conf.defaultPath;
    name = conf.defaultName;
    } else {
    path = conf.path;
    name = conf.pathName;
    }
    document.querySelector("#file-label").style.display = "none";
    document.querySelector("#spin").style.visibility = "visible";
    document.getElementById("phyloName").innerHTML = name;
    document.querySelector("#phyloName").style.visibility = "visible";
    readJson(path,function(data2){
    phylo = JSON.parse(data2);
    unhide("static");
    draw(phylo);
    })
    }
    })
    })
    function readPhylo(file) {
    var reader = new FileReader();
    reader.onload = (function(f) {
    return function(e) {
    try {
    json = JSON.parse(e.target.result);
    unhide("explorable");
    draw(json)
    } catch (error) {
    console.log(error)
    }
    };
    })(file);
    reader.readAsText(file, "UTF-8");
    /**
    * @name yearToDate
    * @param {string} year
    * @returns {Date}
    */
    function yearToDate(year) {
    var d = new Date();
    d.setYear(parseInt(year));
    d.setMonth(0);
    d.setDate(1);
    return d;
    }
    // display the Draw button after loading a phylo
    document.querySelector("#file-path").onchange = function(){
    document.querySelector("#file-name").textContent = (this.files[0].name).substring(0,15) + "...";
    // document.querySelector("#file-name").textContent = this.files[0].name;
    document.querySelector("#draw").style.display = "inline-block";
    /**
    * @name stringToDate
    * @param {string} str
    * @returns {Date}
    */
    function stringToDate(str) {
    var arr = (str.replace('"','')).split('-');
    var d = new Date();
    d.setYear(parseInt(arr[0]));
    d.setMonth(parseInt(arr[1]));
    d.setMonth(d.getMonth() - 1);
    d.setDate(parseInt(arr[2]));
    return d;
    }
    // draw the phylo
    document.querySelector("#draw").onclick = function() {
    document.querySelector("#spin").style.visibility = "visible";
    readPhylo(document.getElementById("file-path").files[0]);
    /**
    * @name utcStringToDate
    * @param {string} str
    * @returns {Date}
    */
    function utcStringToDate(str) {
    var arr = ((str.replace('"','')).replace(' UTC','')).split(/[\s-:]+/);
    var d = new Date();
    d.setYear(parseInt(arr[0]));
    d.setMonth(parseInt(arr[1]));
    d.setDate(parseInt(arr[2]));
    d.setHours(parseInt(arr[3]), parseInt(arr[4]), parseInt(arr[5]))
    return d;
    }
    function drawPhyloInfo(elemClass, docs, foundations, branches, groups, terms, periods) {
    ReactDOM.render(React.createElement(phyloCorpus,{}),document.getElementById('phyloCorpus'));
    ReactDOM.render(React.createElement(phyloPhylo,{}),document.getElementById('phyloPhylo'));
    ReactDOM.render(React.createElement(phyloHow,{}),document.getElementById('phyloHow'));
    ReactDOM.render(React.createElement(phyloCorpusInfo,{
    nbDocs : docs,
    nbFoundations : foundations,
    nbPeriods : periods
    }),document.getElementById('phyloCorpusInfo'));
    ReactDOM.render(React.createElement(phyloPhyloInfo,{
    nbTerms : terms,
    nbGroups : groups,
    nbBranches : branches
    }),document.getElementById('phyloPhyloInfo'));
    }
    exports.yearToDate = yearToDate;
    exports.stringToDate = stringToDate;
    exports.utcStringToDate = utcStringToDate;
    function draw(json) {
    // draw PhyloInfo
    window.freq = {};
    window.terms = {};
    window.sources = [];
    window.nbDocs = parseFloat(json.phyloDocs);
    window.nbBranches = parseFloat(json.phyloBranches);
    window.nbGroups = parseFloat(json.phyloGroups);
    window.nbTerms = parseFloat(json.phyloTerms);
    window.nbPeriods = parseFloat(json.phyloPeriods);
    window.nbFoundations = parseFloat(json.phyloFoundations);
    window.timeScale = json.phyloTimeScale;
    if (json.phyloSources != undefined) {
    var sources = stringArrToArr(json.phyloSources);
    var checkSource = document.getElementById("checkSource");
    for (var i = 0; i < sources.length; i++) {
    window.sources.push({source:sources[i],index:i});
    }
    window.sources.sort(function(a, b){
    if(a.source < b.source) { return -1; }
    if(a.source > b.source) { return 1; }
    return 0;
    })
    for (var i = 0; i < window.sources.length; i++) {
    var option = document.createElement("option");
    option.text = window.sources[i].source;
    option.value = window.sources[i].index;
    checkSource.add(option);
    }
    }
    // original bounding box
    bb = ((json.bb).split(',')).map(xy => parseFloat(xy))
    drawPhyloInfo("", window.nbDocs, window.nbFoundations, window.nbBranches, window.nbGroups, window.nbTerms, window.nbPeriods)
    // draw PhyloIsoline
    var branches = json.objects.filter(node => node.nodeType == "branch").map(function(b){
    return { x1 : b.branch_x ,
    y : b.branch_y ,
    x2 : parseFloat(((b.pos).split(','))[0]) ,
    label : b.label,
    bId : parseInt(b.bId),
    gvid : parseInt(b._gvid)
    }
    });
    var periods = json.objects.filter(node => node.nodeType == "period").map(function(p){
    var from = yearToDate(p.from),
    to = yearToDate(p.to);
    if (p.strFrom != undefined) {
    if (window.timeScale == "epoch") {
    from = utcStringToDate(p.strFrom)
    } else {
    from = stringToDate(p.strFrom)
    }
    }
    if (p.strTo != undefined) {
    if (window.timeScale == "epoch") {
    to = utcStringToDate(p.strTo)
    } else {
    to = stringToDate(p.strTo)
    }
    }
    return { from : from,
    to : to,
    y : parseFloat(((p.pos).split(','))[1])}
    });
    // groups
    window.weighted = false;
    ......
    Markdown is supported
    0% or
    You are about to add 0 people to the discussion. Proceed with caution.
    Finish editing this message first!
    Please register or to comment