Implement user blocking

[RiccardoM]

Feature description

In all social networks, users are free to block any other user for any reason. Usually this feature is used after an abusive behavior has taken place, in order to prevent further harassment. Following the implementation of #50 and #168, I think we should definitely implement this feature also inside Desmos.

Implementation proposal

Following you can find the details of the implementation I've thought about this feature.

Types

The following type should be sufficient to represent a user blockage:

// UserBlock represents the fact that the Blocker has blocked the given Blocked user.
// The Reason field represents the reason the user has been blocked for, and is optional. 
type UserBlock struct {
  Blocker  sdk.AccAddress `json:"blocker" yaml:"blocker"`
  Blocked  sdk.AccAddress `json:"blocker" yaml:"blocker"`
  Reason   string         `json:"reason,omitempty" yaml:"reason,omitempty"`
} 

Messages

The operations that should be implemented when talking about user blocking should be:

1. Blocking a user.
2. Unblocking a user.

The following message should do the trick:

// MsgBlockUser allows the given Blocker to block the specified Blocked user 
// for the (optional) reason.
type MsgBlockUser struct {
  Blocker  sdk.AccAddress `json:"blocker" yaml:"blocker"`
  Blocked  sdk.AccAddress `json:"blocker" yaml:"blocker"`
  Reason   string         `json:"reason,omitempty" yaml:"reason,omitempty"`
}

// MsgUnblockUser allows the given original Blocker ot unblock the specified Blocked user.
type MsgUnblockUser struct {
  Blocker  sdk.AccAddress `json:"blocker" yaml:"blocker"`
  Blocked  sdk.AccAddress `json:"blocker" yaml:"blocker"`
}

Keeper

The following methods should be sufficient to implement all the above mentioned operations:

// SaveUserBlock allows to store the given block inside the store, returning an error if 
// something goes wrong
func (k Keeper) SaveUserBlock(ctx sdk.Context, block types.UserBlock) error {} 

// DeleteUserBlock allows to the specified blocker to unblock the given blocked user.
func (k Keeper) UnblockUser(ctx sdk.Context, blocker, blocked sdk.AccAddress) error {} 

// GetUserBlocks returns the list of users that the specified user has blocked.
func (k Keeper) GetUserBlocks(ctx sdl.Context, user sdk.AccAddress) []types.UserBlock {}

Conclusions

@kwunyeung @bragaz let me know what you guys think about this feature and its proposed implementation.

[leobragaz]

Maybe this could be handled in the same way @RiccardoM suggests for the relationship.

[RiccardoM]

@bragaz What do you mean by "relationship"? Could you link the issue or discussion please?

[leobragaz]

sorry the comment is incomplete, I was referring to the fact that when you block someone on mooncake you'll have it blocked even on all the other apps, so maybe we can handle it like you suggested here: #168 (comment)

[leobragaz]

I think I can start with this after merge of #260

[leobragaz]

@RiccardoM What do you think about saving an []sdk.AccAddress instead of a UserBlock the same way we did for the relationships?
So inside the store we will have key = blocker value = []sdk.AccAddress.
We can then attach the reason of blocking inside the handler events.
Doing this I can basically extract some methods from the relationships ones and use the same code for both
saving relationship and blocking user.

[RiccardoM]

@bragaz I think it's better to save the blocking reason inside the storage, otherwise it would be lost when a chain upgrade happens. Also, I think it's better to also save the blocking subspace as well to avoid that some application changes how other applications work.