import Vue from 'vue'
import FtSettingsSection from '../ft-settings-section/ft-settings-section.vue'
import { mapActions, mapMutations } from 'vuex'
import FtCard from '../ft-card/ft-card.vue'
import FtButton from '../ft-button/ft-button.vue'
import FtToggleSwitch from '../ft-toggle-switch/ft-toggle-switch.vue'
import FtFlexBox from '../ft-flex-box/ft-flex-box.vue'
import FtPrompt from '../ft-prompt/ft-prompt.vue'
import { MAIN_PROFILE_ID } from '../../../constants'
import fs from 'fs'
import { opmlToJSON } from 'opml-to-json'
import ytch from 'yt-channel-info'
import { calculateColorLuminance, getRandomColor } from '../../helpers/utils'
// FIXME: Missing web logic branching
export default Vue.extend({
name: 'DataSettings',
components: {
'ft-settings-section': FtSettingsSection,
'ft-card': FtCard,
'ft-button': FtButton,
'ft-toggle-switch': FtToggleSwitch,
'ft-flex-box': FtFlexBox,
'ft-prompt': FtPrompt
},
data: function () {
return {
showImportSubscriptionsPrompt: false,
showExportSubscriptionsPrompt: false,
subscriptionsPromptValues: [
'freetube',
'youtubenew',
'youtube',
'youtubeold',
'newpipe'
]
}
},
computed: {
rememberHistory: function () {
return this.$store.getters.getRememberHistory
},
saveWatchedProgress: function () {
return this.$store.getters.getSaveWatchedProgress
},
backendPreference: function () {
return this.$store.getters.getBackendPreference
},
backendFallback: function () {
return this.$store.getters.getBackendFallback
},
currentInvidiousInstance: function () {
return this.$store.getters.getCurrentInvidiousInstance
},
profileList: function () {
return this.$store.getters.getProfileList
},
allPlaylists: function () {
return this.$store.getters.getAllPlaylists
},
exportSubscriptionsPromptNames: function () {
const exportFreeTube = this.$t('Settings.Data Settings.Export FreeTube')
const exportYouTube = this.$t('Settings.Data Settings.Export YouTube')
const exportNewPipe = this.$t('Settings.Data Settings.Export NewPipe')
return [
`${exportFreeTube} (.db)`,
`${exportYouTube} (.csv)`,
`${exportYouTube} (.json)`,
`${exportYouTube} (.opml)`,
`${exportNewPipe} (.json)`
]
},
usingElectron: function () {
return process.env.IS_ELECTRON
},
primaryProfile: function () {
return JSON.parse(JSON.stringify(this.profileList[0]))
}
},
methods: {
openProfileSettings: function () {
this.$router.push({
path: '/settings/profile/'
})
},
importSubscriptions: async function () {
const options = {
properties: ['openFile'],
filters: [
{
name: this.$t('Settings.Data Settings.Subscription File'),
extensions: ['db', 'csv', 'json', 'opml', 'xml']
}
]
}
const response = await this.showOpenDialog(options)
if (response.canceled || response.filePaths?.length === 0) {
return
}
let textDecode
try {
textDecode = await this.readFileFromDialog({ response })
} catch (err) {
const message = this.$t('Settings.Data Settings.Unable to read file')
this.showToast({
message: `${message}: ${err}`
})
return
}
response.filePaths.forEach(filePath => {
if (filePath.endsWith('.csv')) {
this.importCsvYouTubeSubscriptions(textDecode)
} else if (filePath.endsWith('.db')) {
this.importFreeTubeSubscriptions(textDecode)
} else if (filePath.endsWith('.opml') || filePath.endsWith('.xml')) {
this.importOpmlYouTubeSubscriptions(textDecode)
} else if (filePath.endsWith('.json')) {
textDecode = JSON.parse(textDecode)
if (textDecode.subscriptions) {
this.importNewPipeSubscriptions(textDecode)
} else {
this.importYouTubeSubscriptions(textDecode)
}
}
})
},
importFreeTubeSubscriptions: function (textDecode) {
textDecode = textDecode.split('\n')
textDecode.pop()
textDecode = textDecode.map(data => JSON.parse(data))
const firstEntry = textDecode[0]
if (firstEntry.channelId && firstEntry.channelName && firstEntry.channelThumbnail && firstEntry._id && firstEntry.profile) {
// Old FreeTube subscriptions format detected, so convert it to the new one:
textDecode = this.convertOldFreeTubeFormatToNew(textDecode)
}
textDecode.forEach((profileData) => {
// We would technically already be done by the time the data is parsed,
// however we want to limit the possibility of malicious data being sent
// to the app, so we'll only grab the data we need here.
const requiredKeys = [
'_id',
'name',
'bgColor',
'textColor',
'subscriptions'
]
const profileObject = {}
Object.keys(profileData).forEach((key) => {
if (!requiredKeys.includes(key)) {
const message = this.$t('Settings.Data Settings.Unknown data key')
this.showToast({
message: `${message}: ${key}`
})
} else {
profileObject[key] = profileData[key]
}
})
if (Object.keys(profileObject).length < requiredKeys.length) {
const message = this.$t('Settings.Data Settings.Profile object has insufficient data, skipping item')
this.showToast({
message: message
})
} else {
if (profileObject.name === 'All Channels' || profileObject._id === MAIN_PROFILE_ID) {
this.primaryProfile.subscriptions = this.primaryProfile.subscriptions.concat(profileObject.subscriptions)
this.primaryProfile.subscriptions = this.primaryProfile.subscriptions.filter((sub, index) => {
const profileIndex = this.primaryProfile.subscriptions.findIndex((x) => {
return x.name === sub.name
})
return profileIndex === index
})
this.updateProfile(this.primaryProfile)
} else {
const existingProfileIndex = this.profileList.findIndex((profile) => {
return profile.name.includes(profileObject.name)
})
if (existingProfileIndex !== -1) {
const existingProfile = JSON.parse(JSON.stringify(this.profileList[existingProfileIndex]))
existingProfile.subscriptions = existingProfile.subscriptions.concat(profileObject.subscriptions)
existingProfile.subscriptions = existingProfile.subscriptions.filter((sub, index) => {
const profileIndex = existingProfile.subscriptions.findIndex((x) => {
return x.name === sub.name
})
return profileIndex === index
})
this.updateProfile(existingProfile)
} else {
this.updateProfile(profileObject)
}
this.primaryProfile.subscriptions = this.primaryProfile.subscriptions.concat(profileObject.subscriptions)
this.primaryProfile.subscriptions = this.primaryProfile.subscriptions.filter((sub, index) => {
const profileIndex = this.primaryProfile.subscriptions.findIndex((x) => {
return x.name === sub.name
})
return profileIndex === index
})
this.updateProfile(this.primaryProfile)
}
}
})
this.showToast({
message: this.$t('Settings.Data Settings.All subscriptions and profiles have been successfully imported')
})
},
importCsvYouTubeSubscriptions: async function(textDecode) { // first row = header, last row = empty
const youtubeSubscriptions = textDecode.split('\n').filter(sub => {
return sub !== ''
})
const subscriptions = []
const errorList = []
this.showToast({
message: this.$t('Settings.Data Settings.This might take a while, please wait')
})
this.updateShowProgressBar(true)
this.setProgressBarPercentage(0)
let count = 0
const ytsubs = youtubeSubscriptions.slice(1).map(yt => {
const splitCSVRegex = /(?:,|\n|^)("(?:(?:"")*[^"]*)*"|[^",\n]*|(?:\n|$))/g
return [...yt.matchAll(splitCSVRegex)].map(s => {
let newVal = s[1]
if (newVal.startsWith('"')) {
newVal = newVal.substring(1, newVal.length - 2).replace('""', '"')
}
return newVal
})
}).filter(channel => {
return channel.length > 0
})
new Promise((resolve) => {
let finishCount = 0
ytsubs.forEach(async (yt) => {
const { subscription, result } = await this.subscribeToChannel({
channelId: yt[0],
subscriptions: subscriptions,
channelName: yt[2],
count: count++,
total: ytsubs.length
})
if (result === 1) {
subscriptions.push(subscription)
} else if (result === -1) {
errorList.push(yt)
}
finishCount++
if (finishCount === ytsubs.length) {
resolve(true)
}
})
}).then(_ => {
this.primaryProfile.subscriptions = this.primaryProfile.subscriptions.concat(subscriptions)
this.updateProfile(this.primaryProfile)
if (errorList.length !== 0) {
errorList.forEach(e => { // log it to console for now, dedicated tab for 'error' channels needed
console.error(`failed to import ${e[2]}. Url to channel: ${e[1]}.`)
})
this.showToast({
message: this.$t('Settings.Data Settings.One or more subscriptions were unable to be imported')
})
} else {
this.showToast({
message: this.$t('Settings.Data Settings.All subscriptions have been successfully imported')
})
}
}).finally(_ => {
this.updateShowProgressBar(false)
})
},
importYouTubeSubscriptions: async function (textDecode) {
const subscriptions = []
const errorList = []
this.showToast({
message: this.$t('Settings.Data Settings.This might take a while, please wait')
})
this.updateShowProgressBar(true)
this.setProgressBarPercentage(0)
let count = 0
new Promise((resolve) => {
let finishCount = 0
textDecode.forEach(async (channel) => {
const snippet = channel.snippet
if (typeof snippet === 'undefined') {
const message = this.$t('Settings.Data Settings.Invalid subscriptions file')
this.showToast({
message: message
})
throw new Error('Unable to find channel data')
}
const { subscription, result } = await this.subscribeToChannel({
channelId: snippet.resourceId.channelId,
subscriptions: subscriptions,
channelName: snippet.title,
thumbnail: snippet.thumbnails.default.url,
count: count++,
total: textDecode.length
})
if (result === 1) {
subscriptions.push(subscription)
} else if (result === -1) {
errorList.push([snippet.resourceId.channelId, `https://www.youtube.com/channel/${snippet.resourceId.channelId}`, snippet.title])
}
finishCount++
if (finishCount === textDecode.length) {
resolve(true)
}
})
}).then(_ => {
this.primaryProfile.subscriptions = this.primaryProfile.subscriptions.concat(subscriptions)
this.updateProfile(this.primaryProfile)
if (errorList.length !== 0) {
errorList.forEach(e => { // log it to console for now, dedicated tab for 'error' channels needed
console.error(`failed to import ${e[2]}. Url to channel: ${e[1]}.`)
})
this.showToast({
message: this.$t('Settings.Data Settings.One or more subscriptions were unable to be imported')
})
} else {
this.showToast({
message: this.$t('Settings.Data Settings.All subscriptions have been successfully imported')
})
}
}).finally(_ => {
this.updateShowProgressBar(false)
})
},
importOpmlYouTubeSubscriptions: async function (data) {
let json
try {
json = await opmlToJSON(data)
} catch (err) {
console.error(err)
console.error('error reading')
const message = this.$t('Settings.Data Settings.Invalid subscriptions file')
this.showToast({
message: `${message}: ${err}`
})
}
if (json !== undefined) {
let feedData = json.children[0].children
if (typeof feedData === 'undefined') {
if (json.title.includes('gPodder')) {
feedData = json.children
} else {
const message = this.$t('Settings.Data Settings.Invalid subscriptions file')
this.showToast({
message: message
})
return
}
}
const subscriptions = []
this.showToast({
message: this.$t('Settings.Data Settings.This might take a while, please wait')
})
this.updateShowProgressBar(true)
this.setProgressBarPercentage(0)
let count = 0
feedData.forEach(async (channel, index) => {
const channelId = channel.xmlurl.replace('https://www.youtube.com/feeds/videos.xml?channel_id=', '')
const subExists = this.primaryProfile.subscriptions.findIndex((sub) => {
return sub.id === channelId
})
if (subExists === -1) {
let channelInfo
if (this.backendPreference === 'invidious') {
channelInfo = await this.getChannelInfoInvidious(channelId)
} else {
channelInfo = await this.getChannelInfoLocal(channelId)
}
if (typeof channelInfo.author !== 'undefined') {
const subscription = {
id: channelId,
name: channelInfo.author,
thumbnail: channelInfo.authorThumbnails[1].url
}
subscriptions.push(subscription)
}
}
count++
const progressPercentage = (count / feedData.length) * 100
this.setProgressBarPercentage(progressPercentage)
if (count === feedData.length) {
this.primaryProfile.subscriptions = this.primaryProfile.subscriptions.concat(subscriptions)
this.updateProfile(this.primaryProfile)
if (subscriptions.length < count) {
this.showToast({
message: this.$t('Settings.Data Settings.One or more subscriptions were unable to be imported')
})
} else {
this.showToast({
message: this.$t('Settings.Data Settings.All subscriptions have been successfully imported')
})
}
this.updateShowProgressBar(false)
}
})
}
},
importNewPipeSubscriptions: async function (newPipeData) {
if (typeof newPipeData.subscriptions === 'undefined') {
this.showToast({
message: this.$t('Settings.Data Settings.Invalid subscriptions file')
})
return
}
const newPipeSubscriptions = newPipeData.subscriptions.filter((channel, index) => {
return channel.service_id === 0
})
const subscriptions = []
const errorList = []
this.showToast({
message: this.$t('Settings.Data Settings.This might take a while, please wait')
})
this.updateShowProgressBar(true)
this.setProgressBarPercentage(0)
let count = 0
new Promise((resolve) => {
let finishCount = 0
newPipeSubscriptions.forEach(async (channel, index) => {
const channelId = channel.url.replace(/https:\/\/(www\.)?youtube\.com\/channel\//, '')
const { subscription, result } = await this.subscribeToChannel({
channelId: channelId,
subscriptions: subscriptions,
channelName: channel.name,
count: count++,
total: newPipeSubscriptions.length
})
if (result === 1) {
subscriptions.push(subscription)
}
if (result === -1) {
errorList.push([channelId, channel.url, channel.name])
}
finishCount++
if (finishCount === newPipeSubscriptions.length) {
resolve(true)
}
})
}).then(_ => {
this.primaryProfile.subscriptions = this.primaryProfile.subscriptions.concat(subscriptions)
this.updateProfile(this.primaryProfile)
if (errorList.count > 0) {
errorList.forEach(e => { // log it to console for now, dedicated tab for 'error' channels needed
console.error(`failed to import ${e[2]}. Url to channel: ${e[1]}.`)
})
this.showToast({
message: this.$t('Settings.Data Settings.One or more subscriptions were unable to be imported')
})
} else {
this.showToast({
message: this.$t('Settings.Data Settings.All subscriptions have been successfully imported')
})
}
}).finally(_ => {
this.updateShowProgressBar(false)
})
},
exportSubscriptions: function (option) {
this.showExportSubscriptionsPrompt = false
if (option === null) {
return
}
switch (option) {
case 'freetube':
this.exportFreeTubeSubscriptions()
break
case 'youtubenew':
this.exportCsvYouTubeSubscriptions()
break
case 'youtube':
this.exportYouTubeSubscriptions()
break
case 'youtubeold':
this.exportOpmlYouTubeSubscriptions()
break
case 'newpipe':
this.exportNewPipeSubscriptions()
break
}
},
exportFreeTubeSubscriptions: async function () {
await this.compactProfiles()
const userData = await this.getUserDataPath()
const subscriptionsDb = `${userData}/profiles.db`
const date = new Date().toISOString().split('T')[0]
const exportFileName = 'freetube-subscriptions-' + date + '.db'
const options = {
defaultPath: exportFileName,
filters: [
{
name: this.$t('Settings.Data Settings.Subscription File'),
extensions: ['db']
}
]
}
const response = await this.showSaveDialog({ options })
if (response.canceled || response.filePath === '') {
// User canceled the save dialog
return
}
const filePath = response.filePath
fs.readFile(subscriptionsDb, (readErr, data) => {
if (readErr) {
const message = this.$t('Settings.Data Settings.Unable to read file')
this.showToast({
message: `${message}: ${readErr}`
})
return
}
fs.writeFile(filePath, data, (writeErr) => {
if (writeErr) {
const message = this.$t('Settings.Data Settings.Unable to write file')
this.showToast({
message: `${message}: ${writeErr}`
})
return
}
this.showToast({
message: this.$t('Settings.Data Settings.Subscriptions have been successfully exported')
})
})
})
},
exportYouTubeSubscriptions: async function () {
const date = new Date().toISOString().split('T')[0]
const exportFileName = 'youtube-subscriptions-' + date + '.json'
const options = {
defaultPath: exportFileName,
filters: [
{
name: this.$t('Settings.Data Settings.Subscription File'),
extensions: ['json']
}
]
}
const subscriptionsObject = this.profileList[0].subscriptions.map((channel) => {
const object = {
contentDetails: {
activityType: 'all',
newItemCount: 0,
totalItemCount: 0
},
etag: '',
id: '',
kind: 'youtube#subscription',
snippet: {
channelId: channel.id,
description: '',
publishedAt: new Date(),
resourceId: {
channelId: channel.id,
kind: 'youtube#channel'
},
thumbnails: {
default: {
url: channel.thumbnail
},
high: {
url: channel.thumbnail
},
medium: {
url: channel.thumbnail
}
},
title: channel.name
}
}
return object
})
const response = await this.showSaveDialog({ options })
if (response.canceled || response.filePath === '') {
// User canceled the save dialog
return
}
const filePath = response.filePath
fs.writeFile(filePath, JSON.stringify(subscriptionsObject), (writeErr) => {
if (writeErr) {
const message = this.$t('Settings.Data Settings.Unable to write file')
this.showToast({
message: `${message}: ${writeErr}`
})
return
}
this.showToast({
message: this.$t('Settings.Data Settings.Subscriptions have been successfully exported')
})
})
},
exportOpmlYouTubeSubscriptions: async function () {
const date = new Date().toISOString().split('T')[0]
const exportFileName = 'youtube-subscriptions-' + date + '.opml'
const options = {
defaultPath: exportFileName,
filters: [
{
name: this.$t('Settings.Data Settings.Subscription File'),
extensions: ['opml']
}
]
}
let opmlData = ''
const endingOpmlString = ''
let count = 0
this.profileList[0].subscriptions.forEach((channel) => {
const channelOpmlString = ``
count++
opmlData += channelOpmlString
if (count === this.profileList[0].subscriptions.length) {
opmlData += endingOpmlString
}
})
const response = await this.showSaveDialog({ options })
if (response.canceled || response.filePath === '') {
// User canceled the save dialog
return
}
const filePath = response.filePath
fs.writeFile(filePath, opmlData, (writeErr) => {
if (writeErr) {
const message = this.$t('Settings.Data Settings.Unable to write file')
this.showToast({
message: `${message}: ${writeErr}`
})
return
}
this.showToast({
message: this.$t('Settings.Data Settings.Subscriptions have been successfully exported')
})
})
},
exportCsvYouTubeSubscriptions: async function () {
const date = new Date().toISOString().split('T')[0]
const exportFileName = 'youtube-subscriptions-' + date + '.csv'
const options = {
defaultPath: exportFileName,
filters: [
{
name: this.$t('Settings.Data Settings.Subscription File'),
extensions: ['csv']
}
]
}
let exportText = 'Channel ID,Channel URL,Channel title\n'
this.profileList[0].subscriptions.forEach((channel) => {
const channelUrl = `https://www.youtube.com/channel/${channel.id}`
let channelName = channel.name
if (channelName.search(',') !== -1) { // add quotations and escape existing quotations if channel has comma in name
channelName = `"${channelName.replaceAll('"', '""')}"`
}
exportText += `${channel.id},${channelUrl},${channelName}\n`
})
exportText += '\n'
const response = await this.showSaveDialog({ options })
if (response.canceled || response.filePath === '') {
// User canceled the save dialog
return
}
const filePath = response.filePath
fs.writeFile(filePath, exportText, (writeErr) => {
if (writeErr) {
const message = this.$t('Settings.Data Settings.Unable to write file')
this.showToast({
message: `${message}: ${writeErr}`
})
return
}
this.showToast({
message: this.$t('Settings.Data Settings.Subscriptions have been successfully exported')
})
})
},
exportNewPipeSubscriptions: async function () {
const date = new Date().toISOString().split('T')[0]
const exportFileName = 'newpipe-subscriptions-' + date + '.json'
const options = {
defaultPath: exportFileName,
filters: [
{
name: this.$t('Settings.Data Settings.Subscription File'),
extensions: ['json']
}
]
}
const newPipeObject = {
app_version: '0.19.8',
app_version_int: 953,
subscriptions: []
}
this.profileList[0].subscriptions.forEach((channel) => {
const channelUrl = `https://www.youtube.com/channel/${channel.id}`
const subscription = {
service_id: 0,
url: channelUrl,
name: channel.name
}
newPipeObject.subscriptions.push(subscription)
})
const response = await this.showSaveDialog({ options })
if (response.canceled || response.filePath === '') {
// User canceled the save dialog
return
}
const filePath = response.filePath
fs.writeFile(filePath, JSON.stringify(newPipeObject), (writeErr) => {
if (writeErr) {
const message = this.$t('Settings.Data Settings.Unable to write file')
this.showToast({
message: `${message}: ${writeErr}`
})
return
}
this.showToast({
message: this.$t('Settings.Data Settings.Subscriptions have been successfully exported')
})
})
},
importHistory: async function () {
const options = {
properties: ['openFile'],
filters: [
{
name: this.$t('Settings.Data Settings.History File'),
extensions: ['db']
}
]
}
const response = await this.showOpenDialog(options)
if (response.canceled || response.filePaths?.length === 0) {
return
}
let textDecode
try {
textDecode = await this.readFileFromDialog({ response })
} catch (err) {
const message = this.$t('Settings.Data Settings.Unable to read file')
this.showToast({
message: `${message}: ${err}`
})
return
}
textDecode = textDecode.split('\n')
textDecode.pop()
textDecode.forEach((history) => {
const historyData = JSON.parse(history)
// We would technically already be done by the time the data is parsed,
// however we want to limit the possibility of malicious data being sent
// to the app, so we'll only grab the data we need here.
const requiredKeys = [
'_id',
'author',
'authorId',
'description',
'isLive',
'lengthSeconds',
'paid',
'published',
'timeWatched',
'title',
'type',
'videoId',
'viewCount',
'watchProgress'
]
const historyObject = {}
Object.keys(historyData).forEach((key) => {
if (!requiredKeys.includes(key)) {
this.showToast({
message: `Unknown data key: ${key}`
})
} else {
historyObject[key] = historyData[key]
}
})
if (Object.keys(historyObject).length < (requiredKeys.length - 2)) {
this.showToast({
message: this.$t('Settings.Data Settings.History object has insufficient data, skipping item')
})
} else {
this.updateHistory(historyObject)
}
})
this.showToast({
message: this.$t('Settings.Data Settings.All watched history has been successfully imported')
})
},
exportHistory: async function () {
await this.compactHistory()
const userData = await this.getUserDataPath()
const historyDb = `${userData}/history.db`
const date = new Date().toISOString().split('T')[0]
const exportFileName = 'freetube-history-' + date + '.db'
const options = {
defaultPath: exportFileName,
filters: [
{
name: this.$t('Settings.Data Settings.Playlist File'),
extensions: ['db']
}
]
}
const response = await this.showSaveDialog({ options })
if (response.canceled || response.filePath === '') {
// User canceled the save dialog
return
}
const filePath = response.filePath
fs.readFile(historyDb, (readErr, data) => {
if (readErr) {
const message = this.$t('Settings.Data Settings.Unable to read file')
this.showToast({
message: `${message}: ${readErr}`
})
return
}
fs.writeFile(filePath, data, (writeErr) => {
if (writeErr) {
const message = this.$t('Settings.Data Settings.Unable to write file')
this.showToast({
message: `${message}: ${writeErr}`
})
return
}
this.showToast({
message: this.$t('Settings.Data Settings.All watched history has been successfully exported')
})
})
})
},
importPlaylists: async function () {
const options = {
properties: ['openFile'],
filters: [
{
name: this.$t('Settings.Data Settings.Playlist File'),
extensions: ['db']
}
]
}
const response = await this.showOpenDialog(options)
if (response.canceled || response.filePaths?.length === 0) {
return
}
let data
try {
data = await this.readFileFromDialog({ response })
} catch (err) {
const message = this.$t('Settings.Data Settings.Unable to read file')
this.showToast({
message: `${message}: ${err}`
})
return
}
const playlists = JSON.parse(data)
playlists.forEach(async (playlistData) => {
// We would technically already be done by the time the data is parsed,
// however we want to limit the possibility of malicious data being sent
// to the app, so we'll only grab the data we need here.
const requiredKeys = [
'playlistName',
'videos'
]
const optionalKeys = [
'_id',
'protected',
'removeOnWatched'
]
const requiredVideoKeys = [
'videoId',
'title',
'author',
'authorId',
'published',
'lengthSeconds',
'timeAdded',
'isLive',
'paid',
'type'
]
const playlistObject = {}
Object.keys(playlistData).forEach((key) => {
if (!requiredKeys.includes(key) && !optionalKeys.includes(key)) {
const message = `${this.$t('Settings.Data Settings.Unknown data key')}: ${key}`
this.showToast({
message: message
})
} else if (key === 'videos') {
const videoArray = []
playlistData.videos.forEach((video) => {
let hasAllKeys = true
requiredVideoKeys.forEach((videoKey) => {
if (!Object.keys(video).includes(videoKey)) {
hasAllKeys = false
}
})
if (hasAllKeys) {
videoArray.push(video)
}
})
playlistObject[key] = videoArray
} else {
playlistObject[key] = playlistData[key]
}
})
const objectKeys = Object.keys(playlistObject)
if ((objectKeys.length < requiredKeys.length) || playlistObject.videos.length === 0) {
const message = this.$t('Settings.Data Settings.Playlist insufficient data', { playlist: playlistData.playlistName })
this.showToast({
message: message
})
} else {
const existingPlaylist = this.allPlaylists.find((playlist) => {
return playlist.playlistName === playlistObject.playlistName
})
if (existingPlaylist !== undefined) {
playlistObject.videos.forEach((video) => {
const existingVideo = existingPlaylist.videos.find((x) => {
return x.videoId === video.videoId
})
if (existingVideo === undefined) {
const payload = {
playlistName: existingPlaylist.playlistName,
videoData: video
}
this.addVideo(payload)
}
})
} else {
this.addPlaylist(playlistObject)
}
}
})
this.showToast({
message: this.$t('Settings.Data Settings.All playlists has been successfully imported')
})
},
exportPlaylists: async function () {
const date = new Date().toISOString().split('T')[0]
const exportFileName = 'freetube-playlists-' + date + '.db'
const options = {
defaultPath: exportFileName,
filters: [
{
name: 'Database File',
extensions: ['db']
}
]
}
const response = await this.showSaveDialog({ options })
if (response.canceled || response.filePath === '') {
// User canceled the save dialog
return
}
const filePath = response.filePath
fs.writeFile(filePath, JSON.stringify(this.allPlaylists), (writeErr) => {
if (writeErr) {
const message = this.$t('Settings.Data Settings.Unable to write file')
this.showToast({
message: `${message}: ${writeErr}`
})
return
}
this.showToast({
message: this.$t('Settings.Data Settings.All playlists has been successfully exported')
})
})
},
convertOldFreeTubeFormatToNew(oldData) {
const convertedData = []
for (const channel of oldData) {
const listOfProfilesAlreadyAdded = []
for (const profile of channel.profile) {
let index = convertedData.findIndex(p => p.name === profile.value)
if (index === -1) { // profile doesn't exist yet
const randomBgColor = getRandomColor()
const contrastyTextColor = calculateColorLuminance(randomBgColor)
convertedData.push({
name: profile.value,
bgColor: randomBgColor,
textColor: contrastyTextColor,
subscriptions: [],
_id: channel._id
})
index = convertedData.length - 1
} else if (listOfProfilesAlreadyAdded.indexOf(index) !== -1) {
continue
}
listOfProfilesAlreadyAdded.push(index)
convertedData[index].subscriptions.push({
id: channel.channelId,
name: channel.channelName,
thumbnail: channel.channelThumbnail
})
}
}
return convertedData
},
getChannelInfoInvidious: function (channelId) {
return new Promise((resolve, reject) => {
const subscriptionsPayload = {
resource: 'channels',
id: channelId,
params: {}
}
this.invidiousAPICall(subscriptionsPayload).then((response) => {
resolve(response)
}).catch((err) => {
console.error(err)
const errorMessage = this.$t('Invidious API Error (Click to copy)')
this.showToast({
message: `${errorMessage}: ${err.responseJSON.error}`,
time: 10000,
action: () => {
this.copyToClipboard({ content: err.responseJSON.error })
}
})
if (this.backendFallback && this.backendPreference === 'invidious') {
this.showToast({
message: this.$t('Falling back to the local API')
})
resolve(this.getChannelInfoLocal(channelId))
} else {
resolve([])
}
})
})
},
getChannelInfoLocal: function (channelId) {
return new Promise((resolve, reject) => {
ytch.getChannelInfo({ channelId: channelId }).then(async (response) => {
resolve(response)
}).catch((err) => {
console.error(err)
const errorMessage = this.$t('Local API Error (Click to copy)')
this.showToast({
message: `${errorMessage}: ${err}`,
time: 10000,
action: () => {
this.copyToClipboard({ content: err })
}
})
if (this.backendFallback && this.backendPreference === 'local') {
this.showToast({
message: this.$t('Falling back to the Invidious API')
})
resolve(this.getChannelInfoInvidious(channelId))
} else {
resolve([])
}
})
})
},
/*
TODO: allow default thumbnail to be used to limit requests to YouTube
(thumbnail will get updated when user goes to their channel page)
Returns:
-1: an error occured
0: already subscribed
1: successfully subscribed
*/
async subscribeToChannel({ channelId, subscriptions, channelName = null, thumbnail = null, count = 0, total = 0 }) {
let result = 1
if (this.isChannelSubscribed(channelId, subscriptions)) {
return { subscription: null, successMessage: 0 }
}
let channelInfo
let subscription = null
if (channelName === null || thumbnail === null) {
try {
if (this.backendPreference === 'invidious') {
channelInfo = await this.getChannelInfoInvidious(channelId)
} else {
channelInfo = await this.getChannelInfoLocal(channelId)
}
} catch (err) {
console.error(err)
result = -1
}
} else {
channelInfo = { author: channelName, authorThumbnails: [null, { url: thumbnail }] }
}
if (typeof channelInfo.author !== 'undefined') {
subscription = {
id: channelId,
name: channelInfo.author,
thumbnail: channelInfo.authorThumbnails[1].url
}
} else {
result = -1
}
const progressPercentage = (count / (total - 1)) * 100
this.setProgressBarPercentage(progressPercentage)
return { subscription, result }
},
isChannelSubscribed(channelId, subscriptions) {
if (channelId === null) { return true }
const subExists = this.primaryProfile.subscriptions.findIndex((sub) => {
return sub.id === channelId
}) !== -1
const subDuplicateExists = subscriptions.findIndex((sub) => {
return sub.id === channelId
}) !== -1
return subExists || subDuplicateExists
},
...mapActions([
'invidiousAPICall',
'updateProfile',
'compactProfiles',
'updateShowProgressBar',
'updateHistory',
'compactHistory',
'showToast',
'showOpenDialog',
'readFileFromDialog',
'showSaveDialog',
'getUserDataPath',
'addPlaylist',
'addVideo',
'copyToClipboard'
]),
...mapMutations([
'setProgressBarPercentage'
])
}
})