end
def load_accounts
- return [] if @account.user_hides_network? && current_account.id != @account.id
+ return [] if hide_results?
default_accounts.merge(paginated_follows).to_a
end
+ def hide_results?
+ (@account.user_hides_network? && current_account.id != @account.id) || (current_account && @account.blocking?(current_account))
+ end
+
def default_accounts
- Account.without_blocking(current_account).includes(:active_relationships, :account_stat).references(:active_relationships)
+ Account.includes(:active_relationships, :account_stat).references(:active_relationships)
end
def paginated_follows
end
def load_accounts
- return [] if @account.user_hides_network? && current_account.id != @account.id
+ return [] if hide_results?
default_accounts.merge(paginated_follows).to_a
end
+ def hide_results?
+ (@account.user_hides_network? && current_account.id != @account.id) || (current_account && @account.blocking?(current_account))
+ end
+
def default_accounts
- Account.without_blocking(current_account).includes(:passive_relationships, :account_stat).references(:passive_relationships)
+ Account.includes(:passive_relationships, :account_stat).references(:passive_relationships)
end
def paginated_follows
class Api::V1::Accounts::StatusesController < Api::BaseController
before_action -> { authorize_if_got_token! :read, :'read:statuses' }
before_action :set_account
- before_action :check_account_suspension
- before_action :check_account_block
after_action :insert_pagination_headers
respond_to :json
@account = Account.find(params[:account_id])
end
- def check_account_suspension
- gone if @account.suspended?
- end
-
- def check_account_block
- gone if current_account.present? && @account.blocking?(current_account)
- end
-
def load_statuses
cached_account_statuses
end
before_action :require_user!, except: [:show, :create]
before_action :set_account, except: [:create]
before_action :check_account_suspension, only: [:show]
- before_action :check_account_block, only: [:show]
before_action :check_enabled_registrations, only: [:create]
respond_to :json
gone if @account.suspended?
end
- def check_account_block
- gone if current_account.present? && @account.blocking?(current_account)
- end
-
def account_params
params.permit(:username, :email, :password, :agreement, :locale)
end
def default_accounts
Account
- .without_blocking(current_account)
.includes(:favourites, :account_stat)
.references(:favourites)
.where(favourites: { status_id: @status.id })
end
def default_accounts
- Account.without_blocking(current_account).includes(:statuses, :account_stat).references(:statuses)
+ Account.includes(:statuses, :account_stat).references(:statuses)
end
def paginated_statuses
safe_join([render(file: Rails.root.join('app', 'javascript', 'images', 'logo.svg')), t('accounts.unfollow')])
end
elsif !(account.memorial? || account.moved?)
- link_to account_follow_path(account), class: 'button logo-button', data: { method: :post } do
+ link_to account_follow_path(account), class: "button logo-button#{account.blocking?(current_account) ? ' disabled' : ''}", data: { method: :post } do
safe_join([render(file: Rails.root.join('app', 'javascript', 'images', 'logo.svg')), t('accounts.follow')])
end
end
} else if (account.getIn(['relationship', 'requested'])) {
actionBtn = <Button className='logo-button' text={intl.formatMessage(messages.requested)} onClick={this.props.onFollow} />;
} else if (!account.getIn(['relationship', 'blocking'])) {
- actionBtn = <Button className={classNames('logo-button', { 'button--destructive': account.getIn(['relationship', 'following']) })} text={intl.formatMessage(account.getIn(['relationship', 'following']) ? messages.unfollow : messages.follow)} onClick={this.props.onFollow} />;
+ actionBtn = <Button disabled={account.getIn(['relationship', 'blocked_by'])} className={classNames('logo-button', { 'button--destructive': account.getIn(['relationship', 'following']) })} text={intl.formatMessage(account.getIn(['relationship', 'following']) ? messages.unfollow : messages.follow)} onClick={this.props.onFollow} />;
} else if (account.getIn(['relationship', 'blocking'])) {
actionBtn = <Button className='logo-button' text={intl.formatMessage(messages.unblock, { name: account.get('username') })} onClick={this.props.onBlock} />;
}
import { FormattedMessage } from 'react-intl';
import { fetchAccountIdentityProofs } from '../../actions/identity_proofs';
+const emptyList = ImmutableList();
+
const mapStateToProps = (state, { params: { accountId }, withReplies = false }) => {
const path = withReplies ? `${accountId}:with_replies` : accountId;
return {
- statusIds: state.getIn(['timelines', `account:${path}`, 'items'], ImmutableList()),
- featuredStatusIds: withReplies ? ImmutableList() : state.getIn(['timelines', `account:${accountId}:pinned`, 'items'], ImmutableList()),
+ statusIds: state.getIn(['timelines', `account:${path}`, 'items'], emptyList),
+ featuredStatusIds: withReplies ? ImmutableList() : state.getIn(['timelines', `account:${accountId}:pinned`, 'items'], emptyList),
isLoading: state.getIn(['timelines', `account:${path}`, 'isLoading']),
- hasMore: state.getIn(['timelines', `account:${path}`, 'hasMore']),
+ hasMore: state.getIn(['timelines', `account:${path}`, 'hasMore']),
+ blockedBy: state.getIn(['relationships', accountId, 'blocked_by'], false),
};
};
isLoading: PropTypes.bool,
hasMore: PropTypes.bool,
withReplies: PropTypes.bool,
+ blockedBy: PropTypes.bool,
};
componentWillMount () {
this.props.dispatch(fetchAccount(accountId));
this.props.dispatch(fetchAccountIdentityProofs(accountId));
+
if (!withReplies) {
this.props.dispatch(expandAccountFeaturedTimeline(accountId));
}
+
this.props.dispatch(expandAccountTimeline(accountId, { withReplies }));
}
if ((nextProps.params.accountId !== this.props.params.accountId && nextProps.params.accountId) || nextProps.withReplies !== this.props.withReplies) {
this.props.dispatch(fetchAccount(nextProps.params.accountId));
this.props.dispatch(fetchAccountIdentityProofs(nextProps.params.accountId));
+
if (!nextProps.withReplies) {
this.props.dispatch(expandAccountFeaturedTimeline(nextProps.params.accountId));
}
+
this.props.dispatch(expandAccountTimeline(nextProps.params.accountId, { withReplies: nextProps.params.withReplies }));
}
}
}
render () {
- const { shouldUpdateScroll, statusIds, featuredStatusIds, isLoading, hasMore } = this.props;
+ const { shouldUpdateScroll, statusIds, featuredStatusIds, isLoading, hasMore, blockedBy } = this.props;
if (!statusIds && isLoading) {
return (
);
}
+ const emptyMessage = blockedBy ? <FormattedMessage id='empty_column.account_unavailable' defaultMessage='Profile unavailable' /> : <FormattedMessage id='empty_column.account_timeline' defaultMessage='No toots here!' />;
+
return (
<Column>
<ColumnBackButton />
prepend={<HeaderContainer accountId={this.props.params.accountId} />}
alwaysPrepend
scrollKey='account_timeline'
- statusIds={statusIds}
+ statusIds={blockedBy ? emptyList : statusIds}
featuredStatusIds={featuredStatusIds}
isLoading={isLoading}
hasMore={hasMore}
onLoadMore={this.handleLoadMore}
shouldUpdateScroll={shouldUpdateScroll}
- emptyMessage={<FormattedMessage id='empty_column.account_timeline' defaultMessage='No toots here!' />}
+ emptyMessage={emptyMessage}
/>
</Column>
);
const mapStateToProps = (state, props) => ({
accountIds: state.getIn(['user_lists', 'followers', props.params.accountId, 'items']),
hasMore: !!state.getIn(['user_lists', 'followers', props.params.accountId, 'next']),
+ blockedBy: state.getIn(['relationships', props.params.accountId, 'blocked_by'], false),
});
export default @connect(mapStateToProps)
shouldUpdateScroll: PropTypes.func,
accountIds: ImmutablePropTypes.list,
hasMore: PropTypes.bool,
+ blockedBy: PropTypes.bool,
};
componentWillMount () {
}, 300, { leading: true });
render () {
- const { shouldUpdateScroll, accountIds, hasMore } = this.props;
+ const { shouldUpdateScroll, accountIds, hasMore, blockedBy } = this.props;
if (!accountIds) {
return (
);
}
- const emptyMessage = <FormattedMessage id='account.followers.empty' defaultMessage='No one follows this user yet.' />;
+ const emptyMessage = blockedBy ? <FormattedMessage id='empty_column.account_unavailable' defaultMessage='Profile unavailable' /> : <FormattedMessage id='account.followers.empty' defaultMessage='No one follows this user yet.' />;
return (
<Column>
alwaysPrepend
emptyMessage={emptyMessage}
>
- {accountIds.map(id =>
+ {blockedBy ? [] : accountIds.map(id =>
<AccountContainer key={id} id={id} withNote={false} />
)}
</ScrollableList>
const mapStateToProps = (state, props) => ({
accountIds: state.getIn(['user_lists', 'following', props.params.accountId, 'items']),
hasMore: !!state.getIn(['user_lists', 'following', props.params.accountId, 'next']),
+ blockedBy: state.getIn(['relationships', props.params.accountId, 'blocked_by'], false),
});
export default @connect(mapStateToProps)
shouldUpdateScroll: PropTypes.func,
accountIds: ImmutablePropTypes.list,
hasMore: PropTypes.bool,
+ blockedBy: PropTypes.bool,
};
componentWillMount () {
}, 300, { leading: true });
render () {
- const { shouldUpdateScroll, accountIds, hasMore } = this.props;
+ const { shouldUpdateScroll, accountIds, hasMore, blockedBy } = this.props;
if (!accountIds) {
return (
);
}
- const emptyMessage = <FormattedMessage id='account.follows.empty' defaultMessage="This user doesn't follow anyone yet." />;
+ const emptyMessage = blockedBy ? <FormattedMessage id='empty_column.account_unavailable' defaultMessage='Profile unavailable' /> : <FormattedMessage id='account.follows.empty' defaultMessage="This user doesn't follow anyone yet." />;
return (
<Column>
alwaysPrepend
emptyMessage={emptyMessage}
>
- {accountIds.map(id =>
+ {blockedBy ? [] : accountIds.map(id =>
<AccountContainer key={id} id={id} withNote={false} />
)}
</ScrollableList>
}
}
- &:disabled {
+ &:disabled,
+ &.disabled {
background-color: $ui-primary-color;
cursor: default;
}
}
}
+ &:disabled,
+ &.disabled {
+ svg path:last-child {
+ fill: $ui-primary-color;
+ }
+
+ &:active,
+ &:focus,
+ &:hover {
+ background: $ui-primary-color;
+
+ svg path:last-child {
+ fill: $ui-primary-color;
+ }
+ }
+ }
+
&.button--destructive {
&:active,
&:focus,
scope :tagged_with, ->(tag) { joins(:accounts_tags).where(accounts_tags: { tag_id: tag }) }
scope :by_recent_status, -> { order(Arel.sql('(case when account_stats.last_status_at is null then 1 else 0 end) asc, account_stats.last_status_at desc')) }
scope :popular, -> { order('account_stats.followers_count desc') }
- scope :without_blocking, ->(account) { account.nil? ? all : where.not(id: Block.where(target_account_id: account.id).pluck(:account_id)) }
delegate :email,
:unconfirmed_email,
# frozen_string_literal: true
class AccountRelationshipsPresenter
- attr_reader :following, :followed_by, :blocking,
+ attr_reader :following, :followed_by, :blocking, :blocked_by,
:muting, :requested, :domain_blocking,
:endorsed
@following = cached[:following].merge(Account.following_map(@uncached_account_ids, @current_account_id))
@followed_by = cached[:followed_by].merge(Account.followed_by_map(@uncached_account_ids, @current_account_id))
@blocking = cached[:blocking].merge(Account.blocking_map(@uncached_account_ids, @current_account_id))
+ @blocked_by = cached[:blocked_by].merge(Account.blocked_by_map(@uncached_account_ids, @current_account_id))
@muting = cached[:muting].merge(Account.muting_map(@uncached_account_ids, @current_account_id))
@requested = cached[:requested].merge(Account.requested_map(@uncached_account_ids, @current_account_id))
@domain_blocking = cached[:domain_blocking].merge(Account.domain_blocking_map(@uncached_account_ids, @current_account_id))
@following.merge!(options[:following_map] || {})
@followed_by.merge!(options[:followed_by_map] || {})
@blocking.merge!(options[:blocking_map] || {})
+ @blocked_by.merge!(options[:blocked_by_map] || {})
@muting.merge!(options[:muting_map] || {})
@requested.merge!(options[:requested_map] || {})
@domain_blocking.merge!(options[:domain_blocking_map] || {})
following: {},
followed_by: {},
blocking: {},
+ blocked_by: {},
muting: {},
requested: {},
domain_blocking: {},
following: { account_id => following[account_id] },
followed_by: { account_id => followed_by[account_id] },
blocking: { account_id => blocking[account_id] },
+ blocked_by: { account_id => blocked_by[account_id] },
muting: { account_id => muting[account_id] },
requested: { account_id => requested[account_id] },
domain_blocking: { account_id => domain_blocking[account_id] },
# frozen_string_literal: true
class REST::RelationshipSerializer < ActiveModel::Serializer
- attributes :id, :following, :showing_reblogs, :followed_by, :blocking,
+ attributes :id, :following, :showing_reblogs, :followed_by, :blocking, :blocked_by,
:muting, :muting_notifications, :requested, :domain_blocking,
:endorsed
instance_options[:relationships].blocking[object.id] || false
end
+ def blocked_by
+ instance_options[:relationships].blocked_by[object.id] || false
+ end
+
def muting
instance_options[:relationships].muting[object.id] ? true : false
end
@options = options
@account = account
- results = search_service_results
-
- unless account.nil?
- account_ids = results.map(&:id)
- blocked_by_map = Account.blocked_by_map(account_ids, account.id)
- results.reject! { |item| blocked_by_map[item.id] }
- end
-
- results
+ search_service_results
end
private
default_results.tap do |results|
if url_query?
results.merge!(url_resource_results) unless url_resource.nil?
- results[:accounts].reject! { |item| item.blocking?(@account) }
- results[:statuses].reject! { |status| StatusFilter.new(status, @account).filtered? }
elsif @query.present?
results[:accounts] = perform_accounts_search! if account_searchable?
results[:statuses] = perform_statuses_search! if full_text_searchable?
= active_link_to t('accounts.posts_with_replies'), short_account_with_replies_url(@account)
= active_link_to t('accounts.media'), short_account_media_url(@account)
- - if @statuses.empty?
+ - if user_signed_in? && @account.blocking?(current_account)
+ .nothing-here.nothing-here--under-tabs= t('accounts.unavailable')
+ - elsif @statuses.empty?
= nothing_here 'nothing-here--under-tabs'
- else
.activity-stream
- if @account.user_hides_network?
.nothing-here= t('accounts.network_hidden')
+- elsif user_signed_in? && @account.blocking?(current_account)
+ .nothing-here= t('accounts.unavailable')
- elsif @follows.empty?
= nothing_here
- else
- if @account.user_hides_network?
.nothing-here= t('accounts.network_hidden')
+- elsif user_signed_in? && @account.blocking?(current_account)
+ .nothing-here= t('accounts.unavailable')
- elsif @follows.empty?
= nothing_here
- else
admin: Admin
bot: Bot
moderator: Mod
+ unavailable: Profile unavailable
unfollow: Unfollow
admin:
account_actions:
let(:token) { Fabricate(:accessible_access_token, resource_owner_id: user.id, scopes: 'read:accounts') }
before do
+ Fabricate(:follow, target_account: user.account)
allow(controller).to receive(:doorkeeper_token) { token }
end
describe 'GET #index' do
- let(:simon) { Fabricate(:account, username: 'simon') }
- let(:lewis) { Fabricate(:account, username: 'lewis') }
-
- before do
- simon.follow!(lewis)
- end
-
it 'returns http success' do
- get :index, params: { account_id: lewis.id, limit: 1 }
+ get :index, params: { account_id: user.account.id, limit: 1 }
expect(response).to have_http_status(200)
end
-
- it 'returns JSON with correct data' do
- get :index, params: { account_id: lewis.id, limit: 1 }
-
- json = body_as_json
-
- expect(json).to be_a Enumerable
- expect(json.first[:username]).to eq 'simon'
- end
-
- it 'does not return accounts blocking you' do
- simon.block!(user.account)
- get :index, params: { account_id: lewis.id, limit: 1 }
-
- json = body_as_json
-
- expect(json).to be_a Enumerable
- expect(json.size).to eq 0
- end
end
end
let(:token) { Fabricate(:accessible_access_token, resource_owner_id: user.id, scopes: 'read:accounts') }
before do
+ Fabricate(:follow, account: user.account)
allow(controller).to receive(:doorkeeper_token) { token }
end
describe 'GET #index' do
- let(:simon) { Fabricate(:account, username: 'simon') }
- let(:lewis) { Fabricate(:account, username: 'lewis') }
-
- before do
- lewis.follow!(simon)
- end
-
it 'returns http success' do
- get :index, params: { account_id: lewis.id, limit: 1 }
+ get :index, params: { account_id: user.account.id, limit: 1 }
expect(response).to have_http_status(200)
end
-
- it 'returns JSON with correct data' do
- get :index, params: { account_id: lewis.id, limit: 1 }
-
- json = body_as_json
-
- expect(json).to be_a Enumerable
- expect(json.first[:username]).to eq 'simon'
- end
-
- it 'does not return accounts blocking you' do
- simon.block!(user.account)
- get :index, params: { account_id: lewis.id, limit: 1 }
-
- json = body_as_json
-
- expect(json).to be_a Enumerable
- expect(json.size).to eq 0
- end
end
end
expect(results).to eq []
end
end
-
- describe 'should not include accounts blocking the requester' do
- let!(:blocked) { Fabricate(:account) }
- let!(:blocker) { Fabricate(:account, username: 'exact') }
-
- before do
- blocker.block!(blocked)
- end
-
- it 'returns the fuzzy match first, and does not return suspended exacts' do
- partial = Fabricate(:account, username: 'exactness')
-
- results = subject.call('exact', blocked, limit: 10)
- expect(results.size).to eq 1
- expect(results).to eq [partial]
- end
- end
end
end
require 'rails_helper'
describe SearchService, type: :service do
- let(:current_account) { Fabricate(:user).account }
-
subject { described_class.new }
describe '#call' do
it 'returns empty results without searching' do
allow(AccountSearchService).to receive(:new)
allow(Tag).to receive(:search_for)
- results = subject.call('', current_account, 10)
+ results = subject.call('', nil, 10)
expect(results).to eq(empty_results)
expect(AccountSearchService).not_to have_received(:new)
it 'returns the empty results' do
service = double(call: nil)
allow(ResolveURLService).to receive(:new).and_return(service)
- results = subject.call(@query, current_account, 10)
+ results = subject.call(@query, nil, 10)
- expect(service).to have_received(:call).with(@query, on_behalf_of: current_account)
+ expect(service).to have_received(:call).with(@query, on_behalf_of: nil)
expect(results).to eq empty_results
end
end
context 'that finds an account' do
it 'includes the account in the results' do
- account = Fabricate(:account)
+ account = Account.new
service = double(call: account)
allow(ResolveURLService).to receive(:new).and_return(service)
- results = subject.call(@query, current_account, 10)
- expect(service).to have_received(:call).with(@query, on_behalf_of: current_account)
+ results = subject.call(@query, nil, 10)
+ expect(service).to have_received(:call).with(@query, on_behalf_of: nil)
expect(results).to eq empty_results.merge(accounts: [account])
end
end
context 'that finds a status' do
it 'includes the status in the results' do
- status = Fabricate(:status)
+ status = Status.new
service = double(call: status)
allow(ResolveURLService).to receive(:new).and_return(service)
- results = subject.call(@query, current_account, 10)
- expect(service).to have_received(:call).with(@query, on_behalf_of: current_account)
+ results = subject.call(@query, nil, 10)
+ expect(service).to have_received(:call).with(@query, on_behalf_of: nil)
expect(results).to eq empty_results.merge(statuses: [status])
end
end
context 'that matches an account' do
it 'includes the account in the results' do
query = 'username'
- account = Fabricate(:account)
+ account = Account.new
service = double(call: [account])
allow(AccountSearchService).to receive(:new).and_return(service)
- results = subject.call(query, current_account, 10)
- expect(service).to have_received(:call).with(query, current_account, limit: 10, offset: 0, resolve: false)
+ results = subject.call(query, nil, 10)
+ expect(service).to have_received(:call).with(query, nil, limit: 10, offset: 0, resolve: false)
expect(results).to eq empty_results.merge(accounts: [account])
end
end
tag = Tag.new
allow(Tag).to receive(:search_for).with('tag', 10, 0).and_return([tag])
- results = subject.call(query, current_account, 10)
+ results = subject.call(query, nil, 10)
expect(Tag).to have_received(:search_for).with('tag', 10, 0)
expect(results).to eq empty_results.merge(hashtags: [tag])
end
query = '@username'
allow(Tag).to receive(:search_for)
- results = subject.call(query, current_account, 10)
+ results = subject.call(query, nil, 10)
expect(Tag).not_to have_received(:search_for)
expect(results).to eq empty_results
end
cat aescling's git repositories / mastodon.git / commitdiff