No OneTemporary
Actions

Size

30 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/components/user_settings/user_settings.js b/src/components/user_settings/user_settings.js
	index ef9398f65..cb0ad9f30 100644
	--- a/src/components/user_settings/user_settings.js
	+++ b/src/components/user_settings/user_settings.js
	@@ -1,299 +1,302 @@
	import { unescape } from 'lodash'

	import TabSwitcher from '../tab_switcher/tab_switcher.js'
	import StyleSwitcher from '../style_switcher/style_switcher.vue'
	import fileSizeFormatService from '../../services/file_size_format/file_size_format.js'

	const UserSettings = {
	data () {
	return {
	newName: this.$store.state.users.currentUser.name,
	newBio: unescape(this.$store.state.users.currentUser.description),
	newLocked: this.$store.state.users.currentUser.locked,
	newNoRichText: this.$store.state.users.currentUser.no_rich_text,
	newDefaultScope: this.$store.state.users.currentUser.default_scope,
	hideFollows: this.$store.state.users.currentUser.hide_follows,
	hideFollowers: this.$store.state.users.currentUser.hide_followers,
	followList: null,
	followImportError: false,
	followsImported: false,
	enableFollowsExport: true,
	avatarUploading: false,
	bannerUploading: false,
	backgroundUploading: false,
	followListUploading: false,
	avatarPreview: null,
	bannerPreview: null,
	backgroundPreview: null,
	avatarUploadError: null,
	bannerUploadError: null,
	backgroundUploadError: null,
	deletingAccount: false,
	deleteAccountConfirmPasswordInput: '',
	deleteAccountError: false,
	changePasswordInputs: [ '', '', '' ],
	changedPassword: false,
	changePasswordError: false,
	activeTab: 'profile'
	}
	},
	components: {
	StyleSwitcher,
	TabSwitcher
	},
	computed: {
	user () {
	return this.$store.state.users.currentUser
	},
	pleromaBackend () {
	return this.$store.state.instance.pleromaBackend
	},
	scopeOptionsEnabled () {
	return this.$store.state.instance.scopeOptionsEnabled
	},
	vis () {
	return {
	public: { selected: this.newDefaultScope === 'public' },
	unlisted: { selected: this.newDefaultScope === 'unlisted' },
	private: { selected: this.newDefaultScope === 'private' },
	direct: { selected: this.newDefaultScope === 'direct' }
	}
	}
	},
	methods: {
	updateProfile () {
	const name = this.newName
	const description = this.newBio
	const locked = this.newLocked
	// Backend notation.
	/* eslint-disable camelcase */
	const default_scope = this.newDefaultScope
	const no_rich_text = this.newNoRichText
	const hide_follows = this.hideFollows
	const hide_followers = this.hideFollowers
	/* eslint-enable camelcase */
	this.$store.state.api.backendInteractor
	.updateProfile({
	params: {
	name,
	description,
	locked,
	// Backend notation.
	/* eslint-disable camelcase */
	default_scope,
	no_rich_text,
	hide_follows,
	hide_followers
	/* eslint-enable camelcase */
	}}).then((user) => {
	if (!user.error) {
	this.$store.commit('addNewUsers', [user])
	this.$store.commit('setCurrentUser', user)
	}
	})
	},
	changeVis (visibility) {
	this.newDefaultScope = visibility
	},
	uploadFile (slot, e) {
	const file = e.target.files[0]
	if (!file) { return }
	if (file.size > this.$store.state.instance[slot + 'limit']) {
	const filesize = fileSizeFormatService.fileSizeFormat(file.size)
	const allowedsize = fileSizeFormatService.fileSizeFormat(this.$store.state.instance[slot + 'limit'])
	this[slot + 'UploadError'] = this.$t('upload.error.base') + ' ' + this.$t('upload.error.file_too_big', {filesize: filesize.num, filesizeunit: filesize.unit, allowedsize: allowedsize.num, allowedsizeunit: allowedsize.unit})
	return
	}
	// eslint-disable-next-line no-undef
	const reader = new FileReader()
	reader.onload = ({target}) => {
	const img = target.result
	this[slot + 'Preview'] = img
	}
	reader.readAsDataURL(file)
	},
	submitAvatar () {
	if (!this.avatarPreview) { return }

	let img = this.avatarPreview
	// eslint-disable-next-line no-undef
	let imginfo = new Image()
	let cropX, cropY, cropW, cropH
	imginfo.src = img
	if (imginfo.height > imginfo.width) {
	cropX = 0
	cropW = imginfo.width
	cropY = Math.floor((imginfo.height - imginfo.width) / 2)
	cropH = imginfo.width
	} else {
	cropY = 0
	cropH = imginfo.height
	cropX = Math.floor((imginfo.width - imginfo.height) / 2)
	cropW = imginfo.height
	}
	this.avatarUploading = true
	this.$store.state.api.backendInteractor.updateAvatar({params: {img, cropX, cropY, cropW, cropH}}).then((user) => {
	if (!user.error) {
	this.$store.commit('addNewUsers', [user])
	this.$store.commit('setCurrentUser', user)
	this.avatarPreview = null
	} else {
	this.avatarUploadError = this.$t('upload.error.base') + user.error
	}
	this.avatarUploading = false
	})
	},
	clearUploadError (slot) {
	this[slot + 'UploadError'] = null
	},
	submitBanner () {
	if (!this.bannerPreview) { return }

	let banner = this.bannerPreview
	// eslint-disable-next-line no-undef
	let imginfo = new Image()
	/* eslint-disable camelcase */
	let offset_top, offset_left, width, height
	imginfo.src = banner
	width = imginfo.width
	height = imginfo.height
	offset_top = 0
	offset_left = 0
	this.bannerUploading = true
	this.$store.state.api.backendInteractor.updateBanner({params: {banner, offset_top, offset_left, width, height}}).then((data) => {
	if (!data.error) {
	let clone = JSON.parse(JSON.stringify(this.$store.state.users.currentUser))
	clone.cover_photo = data.url
	this.$store.commit('addNewUsers', [clone])
	this.$store.commit('setCurrentUser', clone)
	this.bannerPreview = null
	} else {
	this.bannerUploadError = this.$t('upload.error.base') + data.error
	}
	this.bannerUploading = false
	})
	/* eslint-enable camelcase */
	},
	submitBg () {
	if (!this.backgroundPreview) { return }
	let img = this.backgroundPreview
	// eslint-disable-next-line no-undef
	let imginfo = new Image()
	let cropX, cropY, cropW, cropH
	imginfo.src = img
	cropX = 0
	cropY = 0
	cropW = imginfo.width
	cropH = imginfo.width
	this.backgroundUploading = true
	this.$store.state.api.backendInteractor.updateBg({params: {img, cropX, cropY, cropW, cropH}}).then((data) => {
	if (!data.error) {
	let clone = JSON.parse(JSON.stringify(this.$store.state.users.currentUser))
	clone.background_image = data.url
	this.$store.commit('addNewUsers', [clone])
	this.$store.commit('setCurrentUser', clone)
	this.backgroundPreview = null
	} else {
	this.backgroundUploadError = this.$t('upload.error.base') + data.error
	}
	this.backgroundUploading = false
	})
	},
	importFollows () {
	this.followListUploading = true
	const followList = this.followList
	this.$store.state.api.backendInteractor.followImport({params: followList})
	.then((status) => {
	if (status) {
	this.followsImported = true
	} else {
	this.followImportError = true
	}
	this.followListUploading = false
	})
	},
	/* This function takes an Array of Users
	* and outputs a file with all the addresses for the user to download
	*/
	exportPeople (users, filename) {
	// Get all the friends addresses
	var UserAddresses = users.map(function (user) {
	// check is it's a local user
	if (user && user.is_local) {
	// append the instance address
	// eslint-disable-next-line no-undef
	user.screen_name += '@' + location.hostname
	}
	return user.screen_name
	}).join('\n')
	// Make the user download the file
	var fileToDownload = document.createElement('a')
	fileToDownload.setAttribute('href', 'data:text/plain;charset=utf-8,' + encodeURIComponent(UserAddresses))
	fileToDownload.setAttribute('download', filename)
	fileToDownload.style.display = 'none'
	document.body.appendChild(fileToDownload)
	fileToDownload.click()
	document.body.removeChild(fileToDownload)
	},
	exportFollows () {
	this.enableFollowsExport = false
	this.$store.state.api.backendInteractor
	- .fetchFriends({id: this.$store.state.users.currentUser.id})
	+ .fetchFriends({
	+ id: this.$store.state.users.currentUser.id,
	+ isExport: true
	+ })
	.then((friendList) => {
	this.exportPeople(friendList, 'friends.csv')
	setTimeout(() => { this.enableFollowsExport = true }, 2000)
	})
	},
	followListChange () {
	// eslint-disable-next-line no-undef
	let formData = new FormData()
	formData.append('list', this.$refs.followlist.files[0])
	this.followList = formData
	},
	dismissImported () {
	this.followsImported = false
	this.followImportError = false
	},
	confirmDelete () {
	this.deletingAccount = true
	},
	deleteAccount () {
	this.$store.state.api.backendInteractor.deleteAccount({password: this.deleteAccountConfirmPasswordInput})
	.then((res) => {
	if (res.status === 'success') {
	this.$store.dispatch('logout')
	this.$router.push({name: 'root'})
	} else {
	this.deleteAccountError = res.error
	}
	})
	},
	changePassword () {
	const params = {
	password: this.changePasswordInputs[0],
	newPassword: this.changePasswordInputs[1],
	newPasswordConfirmation: this.changePasswordInputs[2]
	}
	this.$store.state.api.backendInteractor.changePassword(params)
	.then((res) => {
	if (res.status === 'success') {
	this.changedPassword = true
	this.changePasswordError = false
	this.logout()
	} else {
	this.changedPassword = false
	this.changePasswordError = res.error
	}
	})
	},
	activateTab (tabName) {
	this.activeTab = tabName
	},
	logout () {
	this.$store.dispatch('logout')
	this.$router.replace('/')
	}
	}
	}

	export default UserSettings
	diff --git a/src/services/api/api.service.js b/src/services/api/api.service.js
	index d4d52ab14..cf0c2eb2c 100644
	--- a/src/services/api/api.service.js
	+++ b/src/services/api/api.service.js
	@@ -1,572 +1,575 @@
	/* eslint-env browser */
	const LOGIN_URL = '/api/account/verify_credentials.json'
	const FRIENDS_TIMELINE_URL = '/api/statuses/friends_timeline.json'
	const ALL_FOLLOWING_URL = '/api/qvitter/allfollowing'
	const PUBLIC_TIMELINE_URL = '/api/statuses/public_timeline.json'
	const PUBLIC_AND_EXTERNAL_TIMELINE_URL = '/api/statuses/public_and_external_timeline.json'
	const TAG_TIMELINE_URL = '/api/statusnet/tags/timeline'
	const FAVORITE_URL = '/api/favorites/create'
	const UNFAVORITE_URL = '/api/favorites/destroy'
	const RETWEET_URL = '/api/statuses/retweet'
	const UNRETWEET_URL = '/api/statuses/unretweet'
	const STATUS_UPDATE_URL = '/api/statuses/update.json'
	const STATUS_DELETE_URL = '/api/statuses/destroy'
	const STATUS_URL = '/api/statuses/show'
	const MEDIA_UPLOAD_URL = '/api/statusnet/media/upload'
	const CONVERSATION_URL = '/api/statusnet/conversation'
	const MENTIONS_URL = '/api/statuses/mentions.json'
	const DM_TIMELINE_URL = '/api/statuses/dm_timeline.json'
	const FOLLOWERS_URL = '/api/statuses/followers.json'
	const FRIENDS_URL = '/api/statuses/friends.json'
	const FOLLOWING_URL = '/api/friendships/create.json'
	const UNFOLLOWING_URL = '/api/friendships/destroy.json'
	const QVITTER_USER_PREF_URL = '/api/qvitter/set_profile_pref.json'
	const REGISTRATION_URL = '/api/account/register.json'
	const AVATAR_UPDATE_URL = '/api/qvitter/update_avatar.json'
	const BG_UPDATE_URL = '/api/qvitter/update_background_image.json'
	const BANNER_UPDATE_URL = '/api/account/update_profile_banner.json'
	const PROFILE_UPDATE_URL = '/api/account/update_profile.json'
	const EXTERNAL_PROFILE_URL = '/api/externalprofile/show.json'
	const QVITTER_USER_TIMELINE_URL = '/api/qvitter/statuses/user_timeline.json'
	const QVITTER_USER_NOTIFICATIONS_URL = '/api/qvitter/statuses/notifications.json'
	const QVITTER_USER_NOTIFICATIONS_READ_URL = '/api/qvitter/statuses/notifications/read.json'
	const BLOCKING_URL = '/api/blocks/create.json'
	const UNBLOCKING_URL = '/api/blocks/destroy.json'
	const USER_URL = '/api/users/show.json'
	const FOLLOW_IMPORT_URL = '/api/pleroma/follow_import'
	const DELETE_ACCOUNT_URL = '/api/pleroma/delete_account'
	const CHANGE_PASSWORD_URL = '/api/pleroma/change_password'
	const FOLLOW_REQUESTS_URL = '/api/pleroma/friend_requests'
	const APPROVE_USER_URL = '/api/pleroma/friendships/approve'
	const DENY_USER_URL = '/api/pleroma/friendships/deny'
	const SUGGESTIONS_URL = '/api/v1/suggestions'

	const MASTODON_USER_FAVORITES_TIMELINE_URL = '/api/v1/favourites'

	import { each, map } from 'lodash'
	import { parseStatus, parseUser, parseNotification } from '../entity_normalizer/entity_normalizer.service.js'
	import 'whatwg-fetch'

	const oldfetch = window.fetch

	let fetch = (url, options) => {
	options = options \|\| {}
	const baseUrl = ''
	const fullUrl = baseUrl + url
	options.credentials = 'same-origin'
	return oldfetch(fullUrl, options)
	}

	// Params
	// cropH
	// cropW
	// cropX
	// cropY
	// img (base 64 encodend data url)
	const updateAvatar = ({credentials, params}) => {
	let url = AVATAR_UPDATE_URL

	const form = new FormData()

	each(params, (value, key) => {
	if (value) {
	form.append(key, value)
	}
	})

	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST',
	body: form
	}).then((data) => data.json())
	}

	const updateBg = ({credentials, params}) => {
	let url = BG_UPDATE_URL

	const form = new FormData()

	each(params, (value, key) => {
	if (value) {
	form.append(key, value)
	}
	})

	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST',
	body: form
	}).then((data) => data.json())
	}

	// Params
	// height
	// width
	// offset_left
	// offset_top
	// banner (base 64 encodend data url)
	const updateBanner = ({credentials, params}) => {
	let url = BANNER_UPDATE_URL

	const form = new FormData()

	each(params, (value, key) => {
	if (value) {
	form.append(key, value)
	}
	})

	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST',
	body: form
	}).then((data) => data.json())
	}

	// Params
	// name
	// url
	// location
	// description
	const updateProfile = ({credentials, params}) => {
	// Always include these fields, because they might be empty or false
	const fields = ['description', 'locked', 'no_rich_text', 'hide_follows', 'hide_followers']
	let url = PROFILE_UPDATE_URL

	const form = new FormData()

	each(params, (value, key) => {
	if (fields.includes(key) \|\| value) {
	form.append(key, value)
	}
	})
	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST',
	body: form
	}).then((data) => data.json())
	}

	// Params needed:
	// nickname
	// email
	// fullname
	// password
	// password_confirm
	//
	// Optional
	// bio
	// homepage
	// location
	// token
	const register = (params) => {
	const form = new FormData()

	each(params, (value, key) => {
	if (value) {
	form.append(key, value)
	}
	})

	return fetch(REGISTRATION_URL, {
	method: 'POST',
	body: form
	})
	}

	const getCaptcha = () => fetch('/api/pleroma/captcha').then(resp => resp.json())

	const authHeaders = (accessToken) => {
	if (accessToken) {
	return { 'Authorization': `Bearer ${accessToken}` }
	} else {
	return { }
	}
	}

	const externalProfile = ({profileUrl, credentials}) => {
	let url = `${EXTERNAL_PROFILE_URL}?profileurl=${profileUrl}`
	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'GET'
	}).then((data) => data.json())
	}

	const followUser = ({id, credentials}) => {
	let url = `${FOLLOWING_URL}?user_id=${id}`
	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}

	const unfollowUser = ({id, credentials}) => {
	let url = `${UNFOLLOWING_URL}?user_id=${id}`
	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}

	const blockUser = ({id, credentials}) => {
	let url = `${BLOCKING_URL}?user_id=${id}`
	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}

	const unblockUser = ({id, credentials}) => {
	let url = `${UNBLOCKING_URL}?user_id=${id}`
	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}

	const approveUser = ({id, credentials}) => {
	let url = `${APPROVE_USER_URL}?user_id=${id}`
	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}

	const denyUser = ({id, credentials}) => {
	let url = `${DENY_USER_URL}?user_id=${id}`
	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}

	const fetchUser = ({id, credentials}) => {
	let url = `${USER_URL}?user_id=${id}`
	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => data.json())
	.then((data) => parseUser(data))
	}

	-const fetchFriends = ({id, page, credentials}) => {
	+const fetchFriends = ({id, page, isExport, credentials}) => {
	let url = `${FRIENDS_URL}?user_id=${id}`
	if (page) {
	url = url + `&page=${page}`
	}
	+ if (isExport !== undefined) {
	+ url = url + `&export=${isExport}`
	+ }
	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => data.json())
	.then((data) => data.map(parseUser))
	}

	const fetchFollowers = ({id, page, credentials}) => {
	let url = `${FOLLOWERS_URL}?user_id=${id}`
	if (page) {
	url = url + `&page=${page}`
	}
	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => data.json())
	.then((data) => data.map(parseUser))
	}

	const fetchAllFollowing = ({username, credentials}) => {
	const url = `${ALL_FOLLOWING_URL}/${username}.json`
	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => data.json())
	.then((data) => data.map(parseUser))
	}

	const fetchFollowRequests = ({credentials}) => {
	const url = FOLLOW_REQUESTS_URL
	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => data.json())
	}

	const fetchConversation = ({id, credentials}) => {
	let url = `${CONVERSATION_URL}/${id}.json?count=100`
	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => {
	if (data.ok) {
	return data
	}
	throw new Error('Error fetching timeline', data)
	})
	.then((data) => data.json())
	.then((data) => data.map(parseStatus))
	}

	const fetchStatus = ({id, credentials}) => {
	let url = `${STATUS_URL}/${id}.json`
	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => {
	if (data.ok) {
	return data
	}
	throw new Error('Error fetching timeline', data)
	})
	.then((data) => data.json())
	.then((data) => parseStatus(data))
	}

	const setUserMute = ({id, credentials, muted = true}) => {
	const form = new FormData()

	const muteInteger = muted ? 1 : 0

	form.append('namespace', 'qvitter')
	form.append('data', muteInteger)
	form.append('topic', `mute:${id}`)

	return fetch(QVITTER_USER_PREF_URL, {
	method: 'POST',
	headers: authHeaders(credentials),
	body: form
	})
	}

	const fetchTimeline = ({timeline, credentials, since = false, until = false, userId = false, tag = false}) => {
	const timelineUrls = {
	public: PUBLIC_TIMELINE_URL,
	friends: FRIENDS_TIMELINE_URL,
	mentions: MENTIONS_URL,
	dms: DM_TIMELINE_URL,
	notifications: QVITTER_USER_NOTIFICATIONS_URL,
	'publicAndExternal': PUBLIC_AND_EXTERNAL_TIMELINE_URL,
	user: QVITTER_USER_TIMELINE_URL,
	media: QVITTER_USER_TIMELINE_URL,
	favorites: MASTODON_USER_FAVORITES_TIMELINE_URL,
	tag: TAG_TIMELINE_URL
	}
	const isNotifications = timeline === 'notifications'
	const params = []

	let url = timelineUrls[timeline]

	if (since) {
	params.push(['since_id', since])
	}
	if (until) {
	params.push(['max_id', until])
	}
	if (userId) {
	params.push(['user_id', userId])
	}
	if (tag) {
	url += `/${tag}.json`
	}
	if (timeline === 'media') {
	params.push(['only_media', 1])
	}

	params.push(['count', 20])

	const queryString = map(params, (param) => `${param[0]}=${param[1]}`).join('&')
	url += `?${queryString}`

	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => {
	if (data.ok) {
	return data
	}
	throw new Error('Error fetching timeline', data)
	})
	.then((data) => data.json())
	.then((data) => data.map(isNotifications ? parseNotification : parseStatus))
	}

	const verifyCredentials = (user) => {
	return fetch(LOGIN_URL, {
	method: 'POST',
	headers: authHeaders(user)
	})
	.then((response) => {
	if (response.ok) {
	return response.json()
	} else {
	return {
	error: response
	}
	}
	})
	.then((data) => data.error ? data : parseUser(data))
	}

	const favorite = ({ id, credentials }) => {
	return fetch(`${FAVORITE_URL}/${id}.json`, {
	headers: authHeaders(credentials),
	method: 'POST'
	})
	}

	const unfavorite = ({ id, credentials }) => {
	return fetch(`${UNFAVORITE_URL}/${id}.json`, {
	headers: authHeaders(credentials),
	method: 'POST'
	})
	}

	const retweet = ({ id, credentials }) => {
	return fetch(`${RETWEET_URL}/${id}.json`, {
	headers: authHeaders(credentials),
	method: 'POST'
	})
	}

	const unretweet = ({ id, credentials }) => {
	return fetch(`${UNRETWEET_URL}/${id}.json`, {
	headers: authHeaders(credentials),
	method: 'POST'
	})
	}

	const postStatus = ({credentials, status, spoilerText, visibility, sensitive, mediaIds, inReplyToStatusId, contentType, noAttachmentLinks}) => {
	const idsText = mediaIds.join(',')
	const form = new FormData()

	form.append('status', status)
	form.append('source', 'Pleroma FE')
	if (noAttachmentLinks) form.append('no_attachment_links', noAttachmentLinks)
	if (spoilerText) form.append('spoiler_text', spoilerText)
	if (visibility) form.append('visibility', visibility)
	if (sensitive) form.append('sensitive', sensitive)
	if (contentType) form.append('content_type', contentType)
	form.append('media_ids', idsText)
	if (inReplyToStatusId) {
	form.append('in_reply_to_status_id', inReplyToStatusId)
	}

	return fetch(STATUS_UPDATE_URL, {
	body: form,
	method: 'POST',
	headers: authHeaders(credentials)
	})
	.then((response) => {
	if (response.ok) {
	return response.json()
	} else {
	return {
	error: response
	}
	}
	})
	.then((data) => data.error ? data : parseStatus(data))
	}

	const deleteStatus = ({ id, credentials }) => {
	return fetch(`${STATUS_DELETE_URL}/${id}.json`, {
	headers: authHeaders(credentials),
	method: 'POST'
	})
	}

	const uploadMedia = ({formData, credentials}) => {
	return fetch(MEDIA_UPLOAD_URL, {
	body: formData,
	method: 'POST',
	headers: authHeaders(credentials)
	})
	.then((response) => response.text())
	.then((text) => (new DOMParser()).parseFromString(text, 'application/xml'))
	}

	const followImport = ({params, credentials}) => {
	return fetch(FOLLOW_IMPORT_URL, {
	body: params,
	method: 'POST',
	headers: authHeaders(credentials)
	})
	.then((response) => response.ok)
	}

	const deleteAccount = ({credentials, password}) => {
	const form = new FormData()

	form.append('password', password)

	return fetch(DELETE_ACCOUNT_URL, {
	body: form,
	method: 'POST',
	headers: authHeaders(credentials)
	})
	.then((response) => response.json())
	}

	const changePassword = ({credentials, password, newPassword, newPasswordConfirmation}) => {
	const form = new FormData()

	form.append('password', password)
	form.append('new_password', newPassword)
	form.append('new_password_confirmation', newPasswordConfirmation)

	return fetch(CHANGE_PASSWORD_URL, {
	body: form,
	method: 'POST',
	headers: authHeaders(credentials)
	})
	.then((response) => response.json())
	}

	const fetchMutes = ({credentials}) => {
	const url = '/api/qvitter/mutes.json'

	return fetch(url, {
	headers: authHeaders(credentials)
	}).then((data) => data.json())
	}

	const suggestions = ({credentials}) => {
	return fetch(SUGGESTIONS_URL, {
	headers: authHeaders(credentials)
	}).then((data) => data.json())
	}

	const markNotificationsAsSeen = ({id, credentials}) => {
	const body = new FormData()

	body.append('latest_id', id)

	return fetch(QVITTER_USER_NOTIFICATIONS_READ_URL, {
	body,
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}

	const apiService = {
	verifyCredentials,
	fetchTimeline,
	fetchConversation,
	fetchStatus,
	fetchFriends,
	fetchFollowers,
	followUser,
	unfollowUser,
	blockUser,
	unblockUser,
	fetchUser,
	favorite,
	unfavorite,
	retweet,
	unretweet,
	postStatus,
	deleteStatus,
	uploadMedia,
	fetchAllFollowing,
	setUserMute,
	fetchMutes,
	register,
	getCaptcha,
	updateAvatar,
	updateBg,
	updateProfile,
	updateBanner,
	externalProfile,
	followImport,
	deleteAccount,
	changePassword,
	fetchFollowRequests,
	approveUser,
	denyUser,
	suggestions,
	markNotificationsAsSeen
	}

	export default apiService
	diff --git a/src/services/backend_interactor_service/backend_interactor_service.js b/src/services/backend_interactor_service/backend_interactor_service.js
	index ed7d4b499..423aeba55 100644
	--- a/src/services/backend_interactor_service/backend_interactor_service.js
	+++ b/src/services/backend_interactor_service/backend_interactor_service.js
	@@ -1,110 +1,110 @@
	import apiService from '../api/api.service.js'
	import timelineFetcherService from '../timeline_fetcher/timeline_fetcher.service.js'

	const backendInteractorService = (credentials) => {
	const fetchStatus = ({id}) => {
	return apiService.fetchStatus({id, credentials})
	}

	const fetchConversation = ({id}) => {
	return apiService.fetchConversation({id, credentials})
	}

	- const fetchFriends = ({id, page}) => {
	- return apiService.fetchFriends({id, page, credentials})
	+ const fetchFriends = ({id, page, isExport = false}) => {
	+ return apiService.fetchFriends({id, page, isExport, credentials})
	}

	const fetchFollowers = ({id, page}) => {
	return apiService.fetchFollowers({id, page, credentials})
	}

	const fetchAllFollowing = ({username}) => {
	return apiService.fetchAllFollowing({username, credentials})
	}

	const fetchUser = ({id}) => {
	return apiService.fetchUser({id, credentials})
	}

	const followUser = (id) => {
	return apiService.followUser({credentials, id})
	}

	const unfollowUser = (id) => {
	return apiService.unfollowUser({credentials, id})
	}

	const blockUser = (id) => {
	return apiService.blockUser({credentials, id})
	}

	const unblockUser = (id) => {
	return apiService.unblockUser({credentials, id})
	}

	const approveUser = (id) => {
	return apiService.approveUser({credentials, id})
	}

	const denyUser = (id) => {
	return apiService.denyUser({credentials, id})
	}

	const startFetching = ({timeline, store, userId = false}) => {
	return timelineFetcherService.startFetching({timeline, store, credentials, userId})
	}

	const setUserMute = ({id, muted = true}) => {
	return apiService.setUserMute({id, muted, credentials})
	}

	const fetchMutes = () => apiService.fetchMutes({credentials})
	const fetchFollowRequests = () => apiService.fetchFollowRequests({credentials})

	const getCaptcha = () => apiService.getCaptcha()
	const register = (params) => apiService.register(params)
	const updateAvatar = ({params}) => apiService.updateAvatar({credentials, params})
	const updateBg = ({params}) => apiService.updateBg({credentials, params})
	const updateBanner = ({params}) => apiService.updateBanner({credentials, params})
	const updateProfile = ({params}) => apiService.updateProfile({credentials, params})

	const externalProfile = (profileUrl) => apiService.externalProfile({profileUrl, credentials})
	const followImport = ({params}) => apiService.followImport({params, credentials})

	const deleteAccount = ({password}) => apiService.deleteAccount({credentials, password})
	const changePassword = ({password, newPassword, newPasswordConfirmation}) => apiService.changePassword({credentials, password, newPassword, newPasswordConfirmation})

	const backendInteractorServiceInstance = {
	fetchStatus,
	fetchConversation,
	fetchFriends,
	fetchFollowers,
	followUser,
	unfollowUser,
	blockUser,
	unblockUser,
	fetchUser,
	fetchAllFollowing,
	verifyCredentials: apiService.verifyCredentials,
	startFetching,
	setUserMute,
	fetchMutes,
	register,
	getCaptcha,
	updateAvatar,
	updateBg,
	updateBanner,
	updateProfile,
	externalProfile,
	followImport,
	deleteAccount,
	changePassword,
	fetchFollowRequests,
	approveUser,
	denyUser
	}

	return backendInteractorServiceInstance
	}

	export default backendInteractorService

File Metadata

Mime Type: text/x-diff
Expires: Wed, May 14, 7:50 AM (1 d, 6 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 166831
Default Alt Text: (30 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions