No OneTemporary
Actions

Size

32 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/docker/pleroma/entrypoint.e2e.sh b/docker/pleroma/entrypoint.e2e.sh
	index 6945cf5b6a..96920eeaef 100644
	--- a/docker/pleroma/entrypoint.e2e.sh
	+++ b/docker/pleroma/entrypoint.e2e.sh
	@@ -1,57 +1,71 @@
	#!/bin/ash

	set -eu

	SEED_SENTINEL_PATH="/var/lib/pleroma/.e2e_seeded"
	+CONFIG_OVERRIDE_PATH="/var/lib/pleroma/config.exs"

	echo "-- Waiting for database..."
	while ! pg_isready -U "${DB_USER:-pleroma}" -d "postgres://${DB_HOST:-db}:${DB_PORT:-5432}/${DB_NAME:-pleroma}" -t 1; do
	sleep 1s
	done

	+echo "-- Writing E2E config overrides..."
	+cat > "$CONFIG_OVERRIDE_PATH" <<'EOF'
	+import Config
	+
	+config :pleroma, Pleroma.Captcha,
	+ enabled: false
	+
	+config :pleroma, :instance,
	+ registrations_open: true,
	+ account_activation_required: false,
	+ approval_required: false
	+EOF
	+
	echo "-- Running migrations..."
	/opt/pleroma/bin/pleroma_ctl migrate

	echo "-- Starting!"
	/opt/pleroma/bin/pleroma start &
	PLEROMA_PID="$!"

	cleanup() {
	if [ -n "${PLEROMA_PID:-}" ] && kill -0 "$PLEROMA_PID" 2>/dev/null; then
	kill -TERM "$PLEROMA_PID"
	wait "$PLEROMA_PID" \|\| true
	fi
	}

	trap cleanup INT TERM

	echo "-- Waiting for API..."
	api_ok="false"
	for _i in $(seq 1 120); do
	if wget -qO- http://127.0.0.1:4000/api/v1/instance >/dev/null 2>&1; then
	api_ok="true"
	break
	fi
	sleep 1s
	done

	if [ "$api_ok" != "true" ]; then
	echo "Timed out waiting for Pleroma API to become available"
	exit 1
	fi

	if [ ! -f "$SEED_SENTINEL_PATH" ]; then
	if [ -n "${E2E_ADMIN_USERNAME:-}" ] && [ -n "${E2E_ADMIN_PASSWORD:-}" ] && [ -n "${E2E_ADMIN_EMAIL:-}" ]; then
	echo "-- Seeding admin user (${E2E_ADMIN_USERNAME})..."
	if ! /opt/pleroma/bin/pleroma_ctl user new "$E2E_ADMIN_USERNAME" "$E2E_ADMIN_EMAIL" --admin --password "$E2E_ADMIN_PASSWORD" -y; then
	echo "-- User already exists (or creation failed), ensuring admin + confirmed..."
	/opt/pleroma/bin/pleroma_ctl user set "$E2E_ADMIN_USERNAME" --admin --confirmed
	fi
	else
	echo "-- Skipping admin seeding (missing E2E_ADMIN_* env)"
	fi

	touch "$SEED_SENTINEL_PATH"
	fi

	wait "$PLEROMA_PID"
	diff --git a/src/modules/users.js b/src/modules/users.js
	index 5563a280e6..e9b56362dc 100644
	--- a/src/modules/users.js
	+++ b/src/modules/users.js
	@@ -1,740 +1,740 @@
	import { compact, map, each, mergeWith, last, concat, uniq, isArray } from 'lodash'

	import backendInteractorService from '../services/backend_interactor_service/backend_interactor_service.js'
	import { windowWidth, windowHeight } from '../services/window_utils/window_utils'
	import apiService from '../services/api/api.service.js'
	import oauthApi from '../services/new_api/oauth.js'
	import { registerPushNotifications, unregisterPushNotifications } from '../services/sw/sw.js'

	import { useInterfaceStore } from 'src/stores/interface.js'
	import { useOAuthStore } from 'src/stores/oauth.js'
	import { useServerSideStorageStore } from 'src/stores/serverSideStorage'

	import { declarations } from 'src/modules/config_declaration'

	// TODO: Unify with mergeOrAdd in statuses.js
	export const mergeOrAdd = (arr, obj, item) => {
	if (!item) { return false }
	const oldItem = obj[item.id]
	if (oldItem) {
	// We already have this, so only merge the new info.
	mergeWith(oldItem, item, mergeArrayLength)
	return { item: oldItem, new: false }
	} else {
	// This is a new item, prepare it
	arr.push(item)
	obj[item.id] = item
	return { item, new: true }
	}
	}

	const mergeArrayLength = (oldValue, newValue) => {
	if (isArray(oldValue) && isArray(newValue)) {
	oldValue.length = newValue.length
	return mergeWith(oldValue, newValue, mergeArrayLength)
	}
	}

	const getNotificationPermission = () => {
	const Notification = window.Notification

	if (!Notification) return Promise.resolve(null)
	if (Notification.permission === 'default') return Notification.requestPermission()
	return Promise.resolve(Notification.permission)
	}

	const blockUser = (store, args) => {
	const id = args.id
	const expiresIn = typeof args === 'object' ? args.expiresIn : 0

	const predictedRelationship = store.state.relationships[id] \|\| { id }
	store.commit('updateUserRelationship', [predictedRelationship])
	store.commit('addBlockId', id)

	return store.rootState.api.backendInteractor.blockUser({ id, expiresIn })
	.then((relationship) => {
	store.commit('updateUserRelationship', [relationship])
	store.commit('addBlockId', id)

	store.commit('removeStatus', { timeline: 'friends', userId: id })
	store.commit('removeStatus', { timeline: 'public', userId: id })
	store.commit('removeStatus', { timeline: 'publicAndExternal', userId: id })
	})
	}

	const unblockUser = (store, id) => {
	return store.rootState.api.backendInteractor.unblockUser({ id })
	.then((relationship) => store.commit('updateUserRelationship', [relationship]))
	}

	const removeUserFromFollowers = (store, id) => {
	return store.rootState.api.backendInteractor.removeUserFromFollowers({ id })
	.then((relationship) => store.commit('updateUserRelationship', [relationship]))
	}

	const editUserNote = (store, { id, comment }) => {
	return store.rootState.api.backendInteractor.editUserNote({ id, comment })
	.then((relationship) => store.commit('updateUserRelationship', [relationship]))
	}

	const muteUser = (store, args) => {
	const id = typeof args === 'object' ? args.id : args
	const expiresIn = typeof args === 'object' ? args.expiresIn : 0

	const predictedRelationship = store.state.relationships[id] \|\| { id }
	store.commit('updateUserRelationship', [predictedRelationship])
	store.commit('addMuteId', id)

	return store.rootState.api.backendInteractor.muteUser({ id, expiresIn })
	.then((relationship) => {
	store.commit('updateUserRelationship', [relationship])
	store.commit('addMuteId', id)
	})
	}

	const unmuteUser = (store, id) => {
	const predictedRelationship = store.state.relationships[id] \|\| { id }
	predictedRelationship.muting = false
	store.commit('updateUserRelationship', [predictedRelationship])

	return store.rootState.api.backendInteractor.unmuteUser({ id })
	.then((relationship) => store.commit('updateUserRelationship', [relationship]))
	}

	const hideReblogs = (store, userId) => {
	return store.rootState.api.backendInteractor.followUser({ id: userId, reblogs: false })
	.then((relationship) => {
	store.commit('updateUserRelationship', [relationship])
	})
	}

	const showReblogs = (store, userId) => {
	return store.rootState.api.backendInteractor.followUser({ id: userId, reblogs: true })
	.then((relationship) => store.commit('updateUserRelationship', [relationship]))
	}

	const muteDomain = (store, domain) => {
	return store.rootState.api.backendInteractor.muteDomain({ domain })
	.then(() => store.commit('addDomainMute', domain))
	}

	const unmuteDomain = (store, domain) => {
	return store.rootState.api.backendInteractor.unmuteDomain({ domain })
	.then(() => store.commit('removeDomainMute', domain))
	}

	export const mutations = {
	tagUser (state, { user: { id }, tag }) {
	const user = state.usersObject[id]
	const tags = user.tags \|\| []
	const newTags = tags.concat([tag])
	user.tags = newTags
	},
	untagUser (state, { user: { id }, tag }) {
	const user = state.usersObject[id]
	const tags = user.tags \|\| []
	const newTags = tags.filter(t => t !== tag)
	user.tags = newTags
	},
	updateRight (state, { user: { id }, right, value }) {
	const user = state.usersObject[id]
	const newRights = user.rights
	newRights[right] = value
	user.rights = newRights
	},
	updateActivationStatus (state, { user: { id }, deactivated }) {
	const user = state.usersObject[id]
	user.deactivated = deactivated
	},
	setCurrentUser (state, user) {
	state.lastLoginName = user.screen_name
	state.currentUser = mergeWith(state.currentUser \|\| {}, user, mergeArrayLength)
	},
	clearCurrentUser (state) {
	state.currentUser = false
	state.lastLoginName = false
	},
	beginLogin (state) {
	state.loggingIn = true
	},
	endLogin (state) {
	state.loggingIn = false
	},
	saveFriendIds (state, { id, friendIds }) {
	const user = state.usersObject[id]
	user.friendIds = uniq(concat(user.friendIds \|\| [], friendIds))
	},
	saveFollowerIds (state, { id, followerIds }) {
	const user = state.usersObject[id]
	user.followerIds = uniq(concat(user.followerIds \|\| [], followerIds))
	},
	// Because frontend doesn't have a reason to keep these stuff in memory
	// outside of viewing someones user profile.
	clearFriends (state, userId) {
	const user = state.usersObject[userId]
	if (user) {
	user.friendIds = []
	}
	},
	clearFollowers (state, userId) {
	const user = state.usersObject[userId]
	if (user) {
	user.followerIds = []
	}
	},
	addNewUsers (state, users) {
	each(users, (user) => {
	if (user.relationship) {
	state.relationships[user.relationship.id] = user.relationship
	}
	const res = mergeOrAdd(state.users, state.usersObject, user)
	const item = res.item
	if (res.new && item.screen_name && !item.screen_name.includes('@')) {
	state.usersByNameObject[item.screen_name.toLowerCase()] = item
	}
	})
	},
	updateUserRelationship (state, relationships) {
	relationships.forEach((relationship) => {
	state.relationships[relationship.id] = relationship
	})
	},
	updateUserInLists (state, { id, inLists }) {
	state.usersObject[id].inLists = inLists
	},
	saveBlockIds (state, blockIds) {
	state.currentUser.blockIds = blockIds
	},
	addBlockId (state, blockId) {
	if (state.currentUser.blockIds.indexOf(blockId) === -1) {
	state.currentUser.blockIds.push(blockId)
	}
	},
	setBlockIdsMaxId (state, blockIdsMaxId) {
	state.currentUser.blockIdsMaxId = blockIdsMaxId
	},
	saveMuteIds (state, muteIds) {
	state.currentUser.muteIds = muteIds
	},
	setMuteIdsMaxId (state, muteIdsMaxId) {
	state.currentUser.muteIdsMaxId = muteIdsMaxId
	},
	addMuteId (state, muteId) {
	if (state.currentUser.muteIds.indexOf(muteId) === -1) {
	state.currentUser.muteIds.push(muteId)
	}
	},
	saveDomainMutes (state, domainMutes) {
	state.currentUser.domainMutes = domainMutes
	},
	addDomainMute (state, domain) {
	if (state.currentUser.domainMutes.indexOf(domain) === -1) {
	state.currentUser.domainMutes.push(domain)
	}
	},
	removeDomainMute (state, domain) {
	const index = state.currentUser.domainMutes.indexOf(domain)
	if (index !== -1) {
	state.currentUser.domainMutes.splice(index, 1)
	}
	},
	setPinnedToUser (state, status) {
	const user = state.usersObject[status.user.id]
	user.pinnedStatusIds = user.pinnedStatusIds \|\| []
	const index = user.pinnedStatusIds.indexOf(status.id)

	if (status.pinned && index === -1) {
	user.pinnedStatusIds.push(status.id)
	} else if (!status.pinned && index !== -1) {
	user.pinnedStatusIds.splice(index, 1)
	}
	},
	setUserForStatus (state, status) {
	status.user = state.usersObject[status.user.id]
	},
	setUserForNotification (state, notification) {
	if (notification.type !== 'follow') {
	notification.action.user = state.usersObject[notification.action.user.id]
	}
	notification.from_profile = state.usersObject[notification.from_profile.id]
	},
	setColor (state, { user: { id }, highlighted }) {
	const user = state.usersObject[id]
	user.highlight = highlighted
	},
	signUpPending (state) {
	state.signUpPending = true
	state.signUpErrors = []
	state.signUpNotice = {}
	},
	signUpSuccess (state) {
	state.signUpPending = false
	},
	signUpFailure (state, errors) {
	state.signUpPending = false
	state.signUpErrors = errors
	state.signUpNotice = {}
	},
	signUpNotice (state, notice) {
	state.signUpPending = false
	state.signUpErrors = []
	state.signUpNotice = notice
	}
	}

	export const getters = {
	findUser: state => query => {
	return state.usersObject[query]
	},
	findUserByName: state => query => {
	return state.usersByNameObject[query.toLowerCase()]
	},
	findUserByUrl: state => query => {
	return state.users
	.find(u => u.statusnet_profile_url &&
	u.statusnet_profile_url.toLowerCase() === query.toLowerCase())
	},
	relationship: state => id => {
	const rel = id && state.relationships[id]
	return rel \|\| { id, loading: true }
	}
	}

	export const defaultState = {
	loggingIn: false,
	lastLoginName: false,
	currentUser: false,
	users: [],
	usersObject: {},
	usersByNameObject: {},
	signUpPending: false,
	signUpErrors: [],
	signUpNotice: {},
	relationships: {}
	}

	const users = {
	state: defaultState,
	mutations,
	getters,
	actions: {
	fetchUserIfMissing (store, id) {
	if (!store.getters.findUser(id)) {
	store.dispatch('fetchUser', id)
	}
	},
	fetchUser (store, id) {
	return store.rootState.api.backendInteractor.fetchUser({ id })
	.then((user) => {
	store.commit('addNewUsers', [user])
	return user
	})
	},
	fetchUserByName (store, name) {
	return store.rootState.api.backendInteractor.fetchUserByName({ name })
	.then((user) => {
	store.commit('addNewUsers', [user])
	return user
	})
	},
	fetchUserRelationship (store, id) {
	if (store.state.currentUser) {
	store.rootState.api.backendInteractor.fetchUserRelationship({ id })
	.then((relationships) => store.commit('updateUserRelationship', relationships))
	}
	},
	fetchUserInLists (store, id) {
	if (store.state.currentUser) {
	store.rootState.api.backendInteractor.fetchUserInLists({ id })
	.then((inLists) => store.commit('updateUserInLists', { id, inLists }))
	}
	},
	fetchBlocks (store, args) {
	const { reset } = args \|\| {}

	const maxId = store.state.currentUser.blockIdsMaxId
	return store.rootState.api.backendInteractor.fetchBlocks({ maxId })
	.then((blocks) => {
	if (reset) {
	store.commit('saveBlockIds', map(blocks, 'id'))
	} else {
	map(blocks, 'id').map(id => store.commit('addBlockId', id))
	}
	if (blocks.length) {
	store.commit('setBlockIdsMaxId', last(blocks).id)
	}
	store.commit('addNewUsers', blocks)
	return blocks
	})
	},
	blockUser (store, data) {
	return blockUser(store, data)
	},
	unblockUser (store, data) {
	return unblockUser(store, data)
	},
	removeUserFromFollowers (store, id) {
	return removeUserFromFollowers(store, id)
	},
	blockUsers (store, data = []) {
	return Promise.all(data.map(d => blockUser(store, d)))
	},
	unblockUsers (store, data = []) {
	return Promise.all(data.map(d => unblockUser(store, d)))
	},
	editUserNote (store, args) {
	return editUserNote(store, args)
	},
	fetchMutes (store, args) {
	const { reset } = args \|\| {}

	const maxId = store.state.currentUser.muteIdsMaxId
	return store.rootState.api.backendInteractor.fetchMutes({ maxId })
	.then((mutes) => {
	if (reset) {
	store.commit('saveMuteIds', map(mutes, 'id'))
	} else {
	map(mutes, 'id').map(id => store.commit('addMuteId', id))
	}
	if (mutes.length) {
	store.commit('setMuteIdsMaxId', last(mutes).id)
	}
	store.commit('addNewUsers', mutes)
	return mutes
	})
	},
	muteUser (store, data) {
	return muteUser(store, data)
	},
	unmuteUser (store, id) {
	return unmuteUser(store, id)
	},
	hideReblogs (store, id) {
	return hideReblogs(store, id)
	},
	showReblogs (store, id) {
	return showReblogs(store, id)
	},
	muteUsers (store, data = []) {
	return Promise.all(data.map(d => muteUser(store, d)))
	},
	unmuteUsers (store, ids = []) {
	return Promise.all(ids.map(d => unmuteUser(store, d)))
	},
	fetchDomainMutes (store) {
	return store.rootState.api.backendInteractor.fetchDomainMutes()
	.then((domainMutes) => {
	store.commit('saveDomainMutes', domainMutes)
	return domainMutes
	})
	},
	muteDomain (store, domain) {
	return muteDomain(store, domain)
	},
	unmuteDomain (store, domain) {
	return unmuteDomain(store, domain)
	},
	muteDomains (store, domains = []) {
	return Promise.all(domains.map(domain => muteDomain(store, domain)))
	},
	unmuteDomains (store, domain = []) {
	return Promise.all(domain.map(domain => unmuteDomain(store, domain)))
	},
	fetchFriends ({ rootState, commit }, id) {
	const user = rootState.users.usersObject[id]
	const maxId = last(user.friendIds)
	return rootState.api.backendInteractor.fetchFriends({ id, maxId })
	.then((friends) => {
	commit('addNewUsers', friends)
	commit('saveFriendIds', { id, friendIds: map(friends, 'id') })
	return friends
	})
	},
	fetchFollowers ({ rootState, commit }, id) {
	const user = rootState.users.usersObject[id]
	const maxId = last(user.followerIds)
	return rootState.api.backendInteractor.fetchFollowers({ id, maxId })
	.then((followers) => {
	commit('addNewUsers', followers)
	commit('saveFollowerIds', { id, followerIds: map(followers, 'id') })
	return followers
	})
	},
	clearFriends ({ commit }, userId) {
	commit('clearFriends', userId)
	},
	clearFollowers ({ commit }, userId) {
	commit('clearFollowers', userId)
	},
	subscribeUser ({ rootState, commit }, id) {
	return rootState.api.backendInteractor.followUser({ id, notify: true })
	.then((relationship) => commit('updateUserRelationship', [relationship]))
	},
	unsubscribeUser ({ rootState, commit }, id) {
	return rootState.api.backendInteractor.followUser({ id, notify: false })
	.then((relationship) => commit('updateUserRelationship', [relationship]))
	},
	toggleActivationStatus ({ rootState, commit }, { user }) {
	const api = user.deactivated ? rootState.api.backendInteractor.activateUser : rootState.api.backendInteractor.deactivateUser
	api({ user })
	.then((user) => { const deactivated = !user.is_active; commit('updateActivationStatus', { user, deactivated }) })
	},
	registerPushNotifications (store) {
	const token = store.state.currentUser.credentials
	const vapidPublicKey = store.rootState.instance.vapidPublicKey
	const isEnabled = store.rootState.config.webPushNotifications
	const notificationVisibility = store.rootState.config.notificationVisibility

	registerPushNotifications(isEnabled, vapidPublicKey, token, notificationVisibility)
	},
	unregisterPushNotifications (store) {
	const token = store.state.currentUser.credentials

	unregisterPushNotifications(token)
	},
	addNewUsers ({ commit }, users) {
	commit('addNewUsers', users)
	},
	addNewStatuses (store, { statuses }) {
	const users = map(statuses, 'user')
	const retweetedUsers = compact(map(statuses, 'retweeted_status.user'))
	store.commit('addNewUsers', users)
	store.commit('addNewUsers', retweetedUsers)

	each(statuses, (status) => {
	// Reconnect users to statuses
	store.commit('setUserForStatus', status)
	// Set pinned statuses to user
	store.commit('setPinnedToUser', status)
	})
	each(compact(map(statuses, 'retweeted_status')), (status) => {
	// Reconnect users to retweets
	store.commit('setUserForStatus', status)
	// Set pinned retweets to user
	store.commit('setPinnedToUser', status)
	})
	},
	addNewNotifications (store, { notifications }) {
	const users = map(notifications, 'from_profile')
	const targetUsers = map(notifications, 'target').filter(_ => _)
	const notificationIds = notifications.map(_ => _.id)
	store.commit('addNewUsers', users)
	store.commit('addNewUsers', targetUsers)

	const notificationsObject = store.rootState.notifications.idStore
	const relevantNotifications = Object.entries(notificationsObject)
	.filter(([k]) => notificationIds.includes(k))
	.map(([, val]) => val)

	// Reconnect users to notifications
	each(relevantNotifications, (notification) => {
	store.commit('setUserForNotification', notification)
	})
	},
	searchUsers ({ rootState, commit }, { query }) {
	return rootState.api.backendInteractor.searchUsers({ query })
	.then((users) => {
	commit('addNewUsers', users)
	return users
	})
	},
	async signUp (store, userInfo) {
	const oauthStore = useOAuthStore()
	store.commit('signUpPending')

	try {
	const token = await oauthStore.ensureAppToken()
	const data = await apiService.register(
	{ credentials: token, params: { ...userInfo } }
	)

	if (data.access_token) {
	store.commit('signUpSuccess')
	oauthStore.setToken(data.access_token)
	- store.dispatch('loginUser', data.access_token)
	+ await store.dispatch('loginUser', data.access_token)
	return 'ok'
	} else { // Request succeeded, but user cannot login yet.
	store.commit('signUpNotice', data)
	return 'request_sent'
	}
	} catch (e) {
	const errors = e.message
	store.commit('signUpFailure', errors)
	throw e
	}
	},
	async getCaptcha (store) {
	return store.rootState.api.backendInteractor.getCaptcha()
	},

	logout (store) {
	const oauth = useOAuthStore()
	const { instance } = store.rootState

	// NOTE: No need to verify the app still exists, because if it doesn't,
	// the token will be invalid too
	return oauth.ensureApp()
	.then((app) => {
	const params = {
	app,
	instance: instance.server,
	token: oauth.userToken
	}

	return oauthApi.revokeToken(params)
	})
	.then(() => {
	store.commit('clearCurrentUser')
	store.dispatch('disconnectFromSocket')
	oauth.clearToken()
	store.dispatch('stopFetchingTimeline', 'friends')
	store.commit('setBackendInteractor', backendInteractorService(oauth.getToken))
	store.dispatch('stopFetchingNotifications')
	store.dispatch('stopFetchingLists')
	store.dispatch('stopFetchingBookmarkFolders')
	store.dispatch('stopFetchingFollowRequests')
	store.commit('clearNotifications')
	store.commit('resetStatuses')
	store.dispatch('resetChats')
	useInterfaceStore().setLastTimeline('public-timeline')
	useInterfaceStore().setLayoutWidth(windowWidth())
	useInterfaceStore().setLayoutHeight(windowHeight())
	store.commit('clearServerSideStorage')
	})
	},
	loginUser (store, accessToken) {
	return new Promise((resolve, reject) => {
	const commit = store.commit
	const dispatch = store.dispatch
	const rootState = store.rootState
	commit('beginLogin')
	store.rootState.api.backendInteractor.verifyCredentials(accessToken)
	.then((data) => {
	if (!data.error) {
	const user = data
	// user.credentials = userCredentials
	user.credentials = accessToken
	user.blockIds = []
	user.muteIds = []
	user.domainMutes = []
	commit('setCurrentUser', user)

	useServerSideStorageStore().setServerSideStorage(user)
	commit('addNewUsers', [user])

	dispatch('fetchEmoji')

	getNotificationPermission()
	.then(permission => useInterfaceStore().setNotificationPermission(permission))

	// Set our new backend interactor
	commit('setBackendInteractor', backendInteractorService(accessToken))

	// Do server-side storage migrations

	// Debug snippet to clean up storage and reset migrations
	/*
	// Reset wordfilter
	Object.keys(
	useServerSideStorageStore().prefsStorage.simple.muteFilters
	).forEach(key => {
	useServerSideStorageStore().unsetPreference({ path: 'simple.muteFilters.' + key, value: null })
	})

	// Reset flag to 0 to re-run migrations
	useServerSideStorageStore().setFlag({ flag: 'configMigration', value: 0 })
	/**/

	const { configMigration } = useServerSideStorageStore().flagStorage
	declarations
	.filter(x => {
	return x.store === 'server-side' &&
	x.migrationNum > 0 &&
	x.migrationNum > configMigration
	})
	.toSorted((a, b) => a.configMigration - b.configMigration)
	.forEach(value => {
	value.migration(useServerSideStorageStore(), store.rootState)
	useServerSideStorageStore().setFlag({ flag: 'configMigration', value: value.migrationNum })
	useServerSideStorageStore().pushServerSideStorage()
	})

	if (user.token) {
	dispatch('setWsToken', user.token)

	// Initialize the shout socket.
	dispatch('initializeSocket')
	}

	const startPolling = () => {
	// Start getting fresh posts.
	dispatch('startFetchingTimeline', { timeline: 'friends' })

	// Start fetching notifications
	dispatch('startFetchingNotifications')

	if (rootState.instance.pleromaChatMessagesAvailable) {
	// Start fetching chats
	dispatch('startFetchingChats')
	}
	}

	dispatch('startFetchingLists')
	dispatch('startFetchingBookmarkFolders')

	if (user.locked) {
	dispatch('startFetchingFollowRequests')
	}

	if (store.getters.mergedConfig.useStreamingApi) {
	dispatch('fetchTimeline', { timeline: 'friends', since: null })
	dispatch('fetchNotifications', { since: null })
	dispatch('enableMastoSockets', true).catch((error) => {
	console.error('Failed initializing MastoAPI Streaming socket', error)
	}).then(() => {
	dispatch('fetchChats', { latest: true })
	setTimeout(() => dispatch('setNotificationsSilence', false), 10000)
	})
	} else {
	startPolling()
	}

	// Get user mutes
	dispatch('fetchMutes')

	useInterfaceStore().setLayoutWidth(windowWidth())
	useInterfaceStore().setLayoutHeight(windowHeight())

	// Fetch our friends
	store.rootState.api.backendInteractor.fetchFriends({ id: user.id })
	.then((friends) => commit('addNewUsers', friends))
	} else {
	const response = data.error
	// Authentication failed
	commit('endLogin')

	// remove authentication token on client/authentication errors
	if ([400, 401, 403, 422].includes(response.status)) {
	useOAuthStore().clearToken()
	}

	if (response.status === 401) {
	reject(new Error('Wrong username or password'))
	} else {
	reject(new Error('An error occurred, please try again'))
	}
	}
	commit('endLogin')
	resolve()
	})
	.catch((error) => {
	console.error(error)
	commit('endLogin')
	reject(new Error('Failed to connect to server, try again'))
	})
	})
	}
	}
	}

	export default users
	diff --git a/test/e2e-playwright/specs/user_smoke.spec.js b/test/e2e-playwright/specs/user_smoke.spec.js
	new file mode 100644
	index 0000000000..080a20d1a6
	--- /dev/null
	+++ b/test/e2e-playwright/specs/user_smoke.spec.js
	@@ -0,0 +1,80 @@
	+import { randomUUID } from 'node:crypto'
	+import { test, expect } from 'playwright/test'
	+
	+const createTestUser = () => {
	+ const id = randomUUID().slice(0, 8)
	+ return {
	+ username: `e2e_${id}`,
	+ fullname: `E2E ${id}`,
	+ email: `e2e_${id}@example.com`,
	+ password: 'e2e-password'
	+ }
	+}
	+
	+const register = async (page, user) => {
	+ await page.goto('/registration')
	+
	+ const registrationForm = page.locator('#main-scroller form.registration-form')
	+ await registrationForm.locator('#sign-up-username').fill(user.username)
	+ await registrationForm.locator('#sign-up-fullname').fill(user.fullname)
	+ await registrationForm.locator('#email').fill(user.email)
	+ await registrationForm.locator('#sign-up-password').fill(user.password)
	+ await registrationForm.locator('#sign-up-password-confirmation').fill(user.password)
	+ await Promise.all([
	+ page.waitForURL(/\/main\/friends/),
	+ registrationForm.getByRole('button', { name: 'Register' }).click()
	+ ])
	+}
	+
	+const logout = async (page) => {
	+ await page.getByTitle('Log out').click()
	+ const confirmLogout = page.getByRole('button', { name: 'Logout', exact: true })
	+ if (await confirmLogout.isVisible()) {
	+ await Promise.all([
	+ page.waitForURL(/\/main\/(public\|all)/),
	+ confirmLogout.click()
	+ ])
	+ } else {
	+ await page.waitForURL(/\/main\/(public\|all)/)
	+ }
	+
	+ await expect(page.locator('#sidebar form.login-form')).toBeVisible()
	+}
	+
	+const login = async (page, user) => {
	+ await page.goto('/login')
	+
	+ const loginForm = page.locator('#main-scroller form.login-form')
	+ await loginForm.locator('#username').fill(user.username)
	+ await loginForm.locator('#password').fill(user.password)
	+ await loginForm.getByRole('button', { name: 'Log in' }).click()
	+
	+ await page.waitForURL(/\/main\/friends/)
	+}
	+
	+test('user can register, log out, and log back in', async ({ page }) => {
	+ const user = createTestUser()
	+ await register(page, user)
	+ await expect(page.getByTitle('Log out')).toBeVisible()
	+
	+ await logout(page)
	+
	+ await login(page, user)
	+ await expect(page.getByTitle('Log out')).toBeVisible()
	+})
	+
	+test('user can post a status', async ({ page }) => {
	+ const user = createTestUser()
	+ await register(page, user)
	+
	+ const statusText = `Hello from ${user.username} (${randomUUID().slice(0, 8)})`
	+ const composer = page.locator('#sidebar .user-panel .post-status-form')
	+ await composer.locator('textarea.form-post-body').fill(statusText)
	+ await Promise.all([
	+ page.waitForResponse((resp) => resp.request().method() === 'POST' && resp.url().includes('/api/v1/statuses') && resp.ok()),
	+ composer.getByRole('button', { name: 'Post', exact: true }).click()
	+ ])
	+
	+ await page.goto(`/users/${user.username}`)
	+ await expect(page.getByText(statusText)).toBeVisible()
	+})
	diff --git a/tools/e2e/run.sh b/tools/e2e/run.sh
	index 5ff2637cee..3c0ba8a362 100644
	--- a/tools/e2e/run.sh
	+++ b/tools/e2e/run.sh
	@@ -1,35 +1,35 @@
	#!/bin/sh

	set -u

	COMPOSE_FILE="docker-compose.e2e.yml"

	: "${COMPOSE_MENU:=false}"
	: "${PLEROMA_IMAGE:=git.pleroma.social:5050/pleroma/pleroma:stable}"
	: "${E2E_ADMIN_USERNAME:=admin}"
	: "${E2E_ADMIN_PASSWORD:=adminadmin}"
	: "${E2E_ADMIN_EMAIL:=admin@example.com}"

	cleanup() {
	docker compose -f "$COMPOSE_FILE" down -v --remove-orphans >/dev/null 2>&1 \|\| true
	}

	cleanup

	trap 'cleanup; exit 130' INT TERM

	set +e
	COMPOSE_MENU="$COMPOSE_MENU" docker compose -f "$COMPOSE_FILE" up --build --remove-orphans --attach e2e --no-log-prefix --abort-on-container-exit --exit-code-from e2e
	result="$?"
	set -e

	if [ "$result" -ne 0 ]; then
	+ docker compose -f "$COMPOSE_FILE" cp e2e:/app/test/e2e-playwright/test-results test/e2e-playwright >/dev/null 2>&1 \|\| true
	+ docker compose -f "$COMPOSE_FILE" cp e2e:/app/test/e2e-playwright/playwright-report test/e2e-playwright >/dev/null 2>&1 \|\| true
	mkdir -p test/e2e-playwright/test-results
	docker compose -f "$COMPOSE_FILE" logs --no-color pleroma db > test/e2e-playwright/test-results/docker-compose.log 2>/dev/null \|\| true
	- docker compose -f "$COMPOSE_FILE" cp e2e:/app/test/e2e-playwright/test-results test/e2e-playwright/test-results >/dev/null 2>&1 \|\| true
	- docker compose -f "$COMPOSE_FILE" cp e2e:/app/test/e2e-playwright/playwright-report test/e2e-playwright/playwright-report >/dev/null 2>&1 \|\| true
	fi

	cleanup

	exit "$result"

File Metadata

Mime Type: text/x-diff
Expires: Sun, Aug 30, 7:03 AM (1 d, 11 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1737849
Default Alt Text: (32 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions