182 lines
5.0 KiB
JavaScript
182 lines
5.0 KiB
JavaScript
import { readdir, readFile } from 'fs'
|
|
import Vue from 'vue'
|
|
import path from 'path'
|
|
import Papa from 'papaparse'
|
|
import moment from 'moment'
|
|
import { appendTag, formatDate, tagFilter } from '../../libs/data_processing'
|
|
|
|
export default {
|
|
namespaced: true,
|
|
state: {
|
|
csv: {},
|
|
month: moment()
|
|
},
|
|
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) => {
|
|
// month date
|
|
return state.month
|
|
},
|
|
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 tagFilter(rows, tags, invert)
|
|
} else {
|
|
if (invert) {
|
|
return rows.filter(r => {
|
|
return r.tags.map(t => t.name.toLowerCase()).toString() === ['cb'].toString()
|
|
})
|
|
} 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')))]
|
|
}
|
|
|
|
},
|
|
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'])
|
|
parsed.data = parsed.data.filter(x => x.Libellé !== undefined)
|
|
parsed.data.forEach(row => {
|
|
appendTag(row, tags, 'Libellé')
|
|
formatDate(row, 'Date')
|
|
})
|
|
|
|
parsed.filename = filename
|
|
context.commit('SET_DATA',
|
|
{ filename: filename, data: parsed }
|
|
)
|
|
},
|
|
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 })
|
|
}
|
|
}
|
|
}
|