comptes/src/store/modules/datas.js

import { readdir, readFile } from 'fs'
import Vue from 'vue'
import path from 'path'
import Papa from 'papaparse'
import moment from 'moment'
import { appendKeywordField, formatDate, keywordFilter } from '../../libs/data_processing'

export default {
  namespaced: true,
  state: {
    csv: {},
    month: ''
  },
  getters: {
    csvs: (state) => {
      // return array of csv filename
      return Object.values(state.csv).sort((a, b) => {
        var filenameA = a.filename.toLowerCase()
        var filenameB = b.filename.toLowerCase()
        if (filenameA < filenameB) {
          return -1
        }
        if (filenameA > filenameB) {
          return 1
        }
        return 0
      })
    },
    rows: (state) => {
      // return all data stored in csv deleting duplicates rows
      return [ ...new Set(Object.values(state.csv).map(csv => csv.data)
        .reduce((acc, d) => acc.concat(d), [])
      )]
    },
    rows_in: (state, getters) => (csv) => {
      // return rows in a specific csv file
      if (csv in getters.csvs) {
        return state.csv[csv].data
      } else {
        console.log('Unkown csv file - ', csv)
      }
    },
    present: (state, getters) => {
      // is there any datas
      return getters.rows.length > 0
    },
    spending_rows: (state, getters) => {
      // return data with negatives 'Montant'
      return getters.rows.filter(x => x.Montant < 0)
    },
    month: (state, getters) => {
      // month date
      if (state.month){
        return state.month
      } else {
        return moment(getters.months.slice(-1)[0], "MMMM YYYY")
      }
    },
    date_filter_rows: (state, getters) => {
      // return rows filtered by date
      return getters.spending_rows.filter(x => {
        return moment(x.Date).isSame(state.month, 'month')
      })
    },
    tag_filter_rows: (state, getters) => (tags, invert, dateFilter = true) => {
      // return rows filtered by tags
      // by default it filters rows by date
      // to disable date filtering set date_filter to false
      var rows
      if (dateFilter) {
        rows = getters.date_filter_rows
      } else {
        rows = getters.spending_rows
      }
      if (tags.length > 0) {
        return keywordFilter(rows, 'tags', tags, invert)
      } else {
        if (invert) {
          return rows.filter(r => {
            return r.tags.length === 0
          })
        } else {
          return rows
        }
      }
    },
    categorie_filter_rows: (state, getters) => (categories, invert, dateFilter = true) => {
      // return rows filtered by categories
      // by default it filters rows by date
      // to disable date filtering set date_filter to false
      var rows
      if (dateFilter) {
        rows = getters.date_filter_rows
      } else {
        rows = getters.spending_rows
      }
      if (categories.length > 0) {
        return keywordFilter(rows, 'categorie', categories, invert)
      } else {
        if (invert) {
          return rows.filter(r => {
            return r.categories.length === 0
          })
        } else {
          return rows
        }
      }
    },
    libelle_filter_rows: (state, getters) => (words, invert) => {
      // return rows filtered by present of words in 'Libellé'
      if (!words) {
        return getters.date_filter_rows
      }
      if (invert) {
        return getters.date_filter_rows.filter(x => {
          return words.every(v => {
            return x.Libellé.indexOf(v) < 0
          })
        })
      } else {
        return getters.date_filter_rows.filter(x => {
          return words.some(v => {
            return x.Libellé.indexOf(v) >= 0
          })
        })
      }
    },
    months: (state, getters) => {
      // Set of month
      return [...new Set(getters.rows.map(x => moment(x.Date).format('MMMM YYYY')))].sort((left, right) => {
        return moment(left, 'MMMM YYYY').diff(moment(right, 'MMMM YYYY'))
      })
    }
  },
  mutations: {
    CLEAR_DATA: (state) => {
      state.csv = {}
    },
    SET_DATA: (state, { filename, data }) => {
      Vue.set(state.csv, filename, data)
    },
    SET_MONTH: (state, { month }) => {
      state.month = month
    }
  },
  actions: {
    load_csvs (context) {
      // Clean state.csv then load csvs files
      context.commit('CLEAR_DATA')
      context.dispatch('find_csvs')
    },
    find_csvs (context) {
      try {
        readdir(context.rootGetters['config/data_dir'], (err, list) => {
          if (err) {
            console.log(err)
          } else {
            var csvs = list.filter(x => {
              return x.split('.').pop() === 'csv'
            })
            for (var i in csvs) {
              context.dispatch('load_csv', csvs[i])
            }
          }
        })
      } catch (e) {
        console.log(e)
      }
    },
    load_csv (context, csv) {
      readFile(path.join(context.rootGetters['config/data_dir'], csv), 'Latin1', (err, content) => {
        if (err) {
          console.log(err)
        } else {
          var parseConfig = {
            header: true
          }
          var parsed = Papa.parse(content, parseConfig)
          context.dispatch('clean_store_data', {
            filename: csv,
            parsed: parsed
          })
        }
      })
    },
    clean_store_data (context, { filename, parsed }) {
      var tags = Object.values(context.rootGetters['config/tags'])
      var categories = Object.values(context.rootGetters['config/categories'])
      parsed.data = parsed.data.filter(x => x.Libellé !== undefined)
      parsed.data.forEach(row => {
        appendKeywordField(row, 'tags', tags, 'Libellé')
        appendKeywordField(row, 'categorie', categories, 'Libellé')
        formatDate(row, 'Date')
      })

      parsed.filename = filename
      context.commit('SET_DATA',
        { filename: filename, data: parsed }
      )
    },
    compute_tags (context) {
      var tags = Object.values(context.rootGetters['config/tags'])
      var categories = Object.values(context.rootGetters['config/categories'])
      Object.values(context.state.csv).forEach(csv => {
        csv.data.forEach(row => {
          appendKeywordField(row, 'tags', tags, 'Libellé')
          appendKeywordField(row, 'categorie', categories, 'Libellé')
        })
        context.commit('SET_DATA',
          { filename: csv.filename, data: csv }
        )
      })
    },
    next_month (context) {
      var next = moment(context.getters.month).add(1, 'months')
      context.commit('SET_MONTH', { month: next })
    },
    prev_month (context) {
      var prev = moment(context.getters.month).subtract(1, 'months')
      context.commit('SET_MONTH', { month: prev })
    },
    set_month (context, month) {
      context.commit('SET_MONTH', { month: month })
    }
  }
}