700 lines
27 KiB
Ruby
700 lines
27 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
module API
|
|
module V2
|
|
module Admin
|
|
# Admin functionality over users table
|
|
class Users < Grape::API
|
|
resource :users do
|
|
helpers ::API::V2::NamedParams
|
|
helpers do
|
|
def permitted_search_params(params)
|
|
params.slice(:uid, :email, :role, :first_name, :last_name, :country, :level, :state, :from, :to, :range)
|
|
end
|
|
|
|
def search(field, value)
|
|
error!({ errors: ['admin.user.non_user_field'] }, 422) unless User.attribute_names.include?(field)
|
|
|
|
User.where("#{field}": value).order('email ASC')
|
|
end
|
|
end
|
|
|
|
desc 'Returns array of users as paginated collection',
|
|
failure: [
|
|
{ code: 401, message: 'Invalid bearer token' }
|
|
],
|
|
success: API::V2::Entities::User
|
|
params do
|
|
optional :extended,
|
|
type: { value: Boolean, message: 'admin.user.non_boolean_extended' },
|
|
default: false,
|
|
desc: 'When true endpoint returns full information about users'
|
|
optional :uid,
|
|
type: String
|
|
optional :email,
|
|
type: String
|
|
optional :role,
|
|
type: String
|
|
optional :country,
|
|
type: String
|
|
optional :level,
|
|
type: Integer
|
|
optional :state,
|
|
type: String
|
|
optional :range,
|
|
type: String,
|
|
values: { value: -> (p){ %w[created updated].include?(p) }, message: 'admin.user.invalid_range' },
|
|
default: 'created'
|
|
optional :ordering,
|
|
values: { value: -> (p){ %w[asc desc].include?(p) }, message: 'user.ordering.invalid_ordering' },
|
|
default: 'asc',
|
|
desc: 'If set, returned values will be sorted in specific order, defaults to \'asc\'.'
|
|
optional :order_by,
|
|
values: { value: -> (p){ User.new.attributes.keys.include?(p) }, message: 'user.ordering.invalid_attribute' },
|
|
default: 'id',
|
|
desc: 'Name of the field, which result will be ordered by.'
|
|
use :timeperiod_filters
|
|
use :pagination_filters
|
|
end
|
|
get do
|
|
admin_authorize! :read, User
|
|
|
|
entity = params[:extended] ? API::V2::Admin::Entities::UserWithProfile : API::V2::Entities::User
|
|
users = API::V2::Queries::UserFilter.new(User.all.order(params[:order_by] => params[:ordering])).call(params).uniq
|
|
present paginate(users), with: entity
|
|
end
|
|
|
|
desc 'Update user attributes',
|
|
failure: [
|
|
{ code: 401, message: 'Invalid bearer token' }
|
|
],
|
|
success: { code: 200, message: 'User attributes were updated' }
|
|
params do
|
|
requires :uid,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'user uniq id'
|
|
optional :state,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'user state'
|
|
optional :otp,
|
|
type: Boolean,
|
|
allow_blank: false,
|
|
desc: 'user 2fa status'
|
|
exactly_one_of :state, :otp, message: 'admin.user.one_of_state_otp'
|
|
end
|
|
post '/update' do
|
|
admin_authorize! :update, User
|
|
|
|
target_user = User.find_by_uid(params[:uid])
|
|
|
|
# Ruby Hash returns array on keys and values
|
|
update_param_key = params.except(:uid).keys.first
|
|
update_param_value = params.except(:uid).values.first
|
|
|
|
error!({ errors: ['admin.user.doesnt_exist'] }, 404) if target_user.nil?
|
|
|
|
if target_user.superadmin? && !current_user.superadmin?
|
|
error!({ errors: ['admin.user.superadmin_change'] }, 422)
|
|
end
|
|
|
|
error!({ errors: ['admin.user.update_himself'] }, 422) if target_user.uid == current_user.uid
|
|
|
|
if update_param_key == 'otp' && update_param_value == true
|
|
error!({ errors: ['admin.user.enable_2fa'] }, 422)
|
|
end
|
|
|
|
if update_param_value == target_user[update_param_key]
|
|
error!({ errors: ["admin.user.#{update_param_key}_no_change"] }, 422)
|
|
end
|
|
|
|
unless target_user.update(update_param_key => update_param_value)
|
|
code_error!(target_user.errors.details, 422)
|
|
end
|
|
|
|
target_user.labels.find_by(key: :otp, scope: :private).delete if target_user.labels.find_by(key: :otp, scope: :private) && update_param_key == 'otp'
|
|
status 200
|
|
end
|
|
|
|
desc 'Update user role',
|
|
failure: [
|
|
{ code: 401, message: 'Invalid bearer token' }
|
|
],
|
|
success: { code: 200, message: 'User role was created' }
|
|
params do
|
|
requires :uid,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'user uniq id'
|
|
requires :role,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'user role'
|
|
end
|
|
post '/role' do
|
|
admin_authorize! :update, User
|
|
|
|
target_user = User.find_by_uid(params[:uid])
|
|
|
|
error!({ errors: ['admin.user.doesnt_exist'] }, 404) if target_user.nil?
|
|
|
|
if target_user.superadmin? && !current_user.superadmin?
|
|
error!({ errors: ['admin.user.superadmin_change'] }, 422)
|
|
end
|
|
|
|
error!({ errors: ['admin.user.update_himself'] }, 422) if target_user.uid == current_user.uid
|
|
|
|
if params[:role] == target_user.role
|
|
error!({ errors: ["admin.user.role_no_change"] }, 422)
|
|
end
|
|
|
|
unless target_user.update(role: params[:role])
|
|
code_error!(target_user.errors.details, 422)
|
|
end
|
|
|
|
status 200
|
|
end
|
|
|
|
desc 'Update user attributes',
|
|
failure: [
|
|
{ code: 401, message: 'Invalid bearer token' }
|
|
],
|
|
success: { code: 200, message: 'User attributes were created' }
|
|
params do
|
|
requires :uid,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'user uniq id'
|
|
optional :email,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'User Email'
|
|
optional :state,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'user state'
|
|
optional :otp,
|
|
type: Boolean,
|
|
allow_blank: false,
|
|
desc: 'user 2fa status'
|
|
exactly_one_of :state, :otp, :email, message: 'admin.user.one_of_state_otp_email'
|
|
end
|
|
put do
|
|
admin_authorize! :update, User
|
|
|
|
target_user = User.find_by_uid(params[:uid])
|
|
|
|
# Ruby Hash returns array on keys and values
|
|
update_param_key = params.except(:uid).keys.first
|
|
update_param_value = params.except(:uid).values.first
|
|
|
|
error!({ errors: ['admin.user.doesnt_exist'] }, 404) if target_user.nil?
|
|
|
|
if target_user.superadmin? && !current_user.superadmin?
|
|
error!({ errors: ['admin.user.superadmin_change'] }, 422)
|
|
end
|
|
|
|
error!({ errors: ['admin.user.update_himself'] }, 422) if target_user.uid == current_user.uid
|
|
|
|
if update_param_key == 'email' && !current_user.superadmin?
|
|
error!({ errors: ['superadmin.user.update_email'] }, 422)
|
|
end
|
|
|
|
if update_param_key == 'otp' && update_param_value == true
|
|
error!({ errors: ['admin.user.enable_2fa'] }, 422)
|
|
end
|
|
|
|
if update_param_value == target_user[update_param_key]
|
|
error!({ errors: ["admin.user.#{update_param_key}_no_change"] }, 422)
|
|
end
|
|
|
|
unless target_user.update(update_param_key => update_param_value)
|
|
code_error!(target_user.errors.details, 422)
|
|
end
|
|
|
|
target_user.labels.find_by(key: :otp, scope: :private).delete if target_user.labels.find_by(key: :otp, scope: :private) && update_param_key == 'otp'
|
|
status 200
|
|
end
|
|
|
|
desc 'Returns array of users with pending or replaced documents as paginated collection',
|
|
failure: [
|
|
{ code: 401, message: 'Invalid bearer token' }
|
|
],
|
|
success: API::V2::Entities::User
|
|
params do
|
|
optional :extended,
|
|
type: { value: Boolean, message: 'admin.user.non_boolean_extended' },
|
|
default: false,
|
|
desc: 'When true endpoint returns full information about users'
|
|
optional :uid,
|
|
type: String
|
|
optional :email,
|
|
type: String
|
|
optional :role,
|
|
type: String
|
|
optional :first_name,
|
|
type: String
|
|
optional :last_name,
|
|
type: String
|
|
optional :country,
|
|
type: String
|
|
optional :level,
|
|
type: Integer
|
|
optional :state,
|
|
type: String
|
|
optional :range,
|
|
type: String,
|
|
values: { value: ->(p) { %w[created updated].include?(p) }, message: 'admin.user.invalid_range' },
|
|
default: 'created'
|
|
use :timeperiod_filters
|
|
use :pagination_filters
|
|
end
|
|
get '/documents/pending' do
|
|
admin_authorize! :read, User
|
|
|
|
users_with_pending_or_replaced_docs = User.with_pending_or_replaced_docs.order('labels.updated_at ASC')
|
|
|
|
users = API::V2::Queries::UserFilter.new(users_with_pending_or_replaced_docs).call(params)
|
|
|
|
entity = params[:extended] ? API::V2::Admin::Entities::UserWithKYC : API::V2::Entities::User
|
|
present paginate(users), with: entity
|
|
end
|
|
|
|
desc 'Returns user documents',
|
|
failure: [
|
|
{ code: 400, message: 'Required params are empty' },
|
|
{ code: 401, message: 'Invalid bearer token' },
|
|
{ code: 404, message: 'doesnt exist' },
|
|
{ code: 422, message: 'Validation errors' }
|
|
],
|
|
success: API::V2::Entities::Document
|
|
params do
|
|
requires :user_uid, type: String
|
|
optional :doc_type, type: String
|
|
optional :doc_category, type: String
|
|
optional :doc_state, type: String
|
|
end
|
|
get '/documents' do
|
|
admin_authorize! :read, User
|
|
|
|
target_user = User.find_by(uid: params[:user_uid])
|
|
error!({ errors: ['admin.document.user_doesnt_exist'] }, 404) unless target_user
|
|
|
|
documents = target_user.documents
|
|
documents = documents.where(doc_type: params[:doc_type]) if params[:doc_type].present?
|
|
documents = documents.where(doc_category: params[:doc_category]) if params[:doc_category].present?
|
|
documents = documents.where(state: params[:doc_state]) if params[:doc_state].present?
|
|
|
|
error!({ errors: ['admin.document.document_doesnt_exist'] }, 404) unless documents
|
|
|
|
present documents, with: API::V2::Entities::Document
|
|
status 200
|
|
end
|
|
|
|
desc 'change documents by admin',
|
|
failure: [
|
|
{ code: 400, message: 'Required params are empty' },
|
|
{ code: 401, message: 'Invalid bearer token' },
|
|
{ code: 404, message: 'doesnt exist' },
|
|
{ code: 422, message: 'Validation errors' }
|
|
],
|
|
success: API::V2::Admin::Entities::Profile
|
|
params do
|
|
requires :user_uid, type: String
|
|
requires :doc_type, type: String
|
|
requires :doc_state, type: String
|
|
end
|
|
put '/documents' do
|
|
admin_authorize! :update, Document
|
|
|
|
target_user = User.find_by(uid: params[:user_uid])
|
|
error!({ errors: ['admin.document.user_doesnt_exist'] }, 404) unless target_user
|
|
|
|
document = target_user.documents.find_by(doc_type: params[:doc_type])
|
|
error!({ errors: ['admin.document.document_doesnt_exist'] }, 404) unless document
|
|
|
|
document.update(state: params['doc_state'])
|
|
code_error!(document.errors.details, 422) if document.errors.any?
|
|
|
|
present document, with: API::V2::Admin::Entities::Document
|
|
status 200
|
|
end
|
|
|
|
namespace :labels do
|
|
desc 'Returns existing labels keys and values',
|
|
failure: [
|
|
{ code: 401, message: 'Invalid bearer token' }
|
|
]
|
|
params do
|
|
end
|
|
get '/list' do
|
|
admin_authorize! :read, User
|
|
|
|
labels = Label.where(scope: 'private').group(:key, :value).size
|
|
|
|
present labels
|
|
end
|
|
|
|
desc 'Returns array of users as paginated collection',
|
|
failure: [
|
|
{ code: 401, message: 'Invalid bearer token' }
|
|
],
|
|
success: API::V2::Entities::User
|
|
params do
|
|
requires :key, type: String, desc: 'Label key'
|
|
requires :value, type: String, desc: 'Label value'
|
|
use :pagination_filters
|
|
end
|
|
get do
|
|
admin_authorize! :read, User
|
|
|
|
users = User.joins(:labels).where(labels: { key: params[:key], value: params[:value] })
|
|
|
|
present paginate(users), with: API::V2::Entities::User
|
|
end
|
|
|
|
desc 'Add label for user',
|
|
failure: [
|
|
{ code: 401, message: 'Invalid bearer token' }
|
|
],
|
|
success: { code: 200, message: 'Label was created' }
|
|
params do
|
|
requires :uid,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'user uniq id'
|
|
requires :key,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'label key. [a-z0-9_-]+ should be used. Min - 3, max - 255 characters.'
|
|
requires :value,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'label value. [A-Za-z0-9_-] should be used. Min - 3, max - 255 characters.'
|
|
optional :description,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'label description. [A-Za-z0-9_-] should be used. max - 255 characters.'
|
|
optional :scope, type: String, desc: "Label scope: 'public' or 'private'. Default is public", allow_blank: false
|
|
end
|
|
post do
|
|
admin_authorize! :create, Label
|
|
|
|
declared_params = declared(params, include_missing: false)
|
|
|
|
target_user = User.find_by_uid(params[:uid])
|
|
error!({ errors: ['admin.user.doesnt_exist'] }, 404) if target_user.nil?
|
|
|
|
if target_user.superadmin? && !current_user.superadmin?
|
|
error!({ errors: ['admin.user.superadmin_change'] }, 422)
|
|
end
|
|
|
|
declared_params[:user_id] = target_user.id
|
|
|
|
label = Label.new(declared_params.except(:uid))
|
|
|
|
code_error!(label.errors.details, 422) unless label.save
|
|
|
|
status 200
|
|
end
|
|
|
|
desc 'Update user label value',
|
|
failure: [
|
|
{ code: 400, message: 'Required params are empty' },
|
|
{ code: 401, message: 'Invalid bearer token' },
|
|
{ code: 404, message: 'Record is not found' },
|
|
{ code: 422, message: 'Validation errors' }
|
|
],
|
|
success: { code: 200, message: 'Label was updated' }
|
|
params do
|
|
requires :uid,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'user uniq id'
|
|
requires :key,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'Label key.'
|
|
requires :scope,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'label key. [a-z0-9_-]+ should be used. Min - 3, max - 255 characters.'
|
|
requires :value,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'Label value.'
|
|
optional :description,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'label description. [A-Za-z0-9_-] should be used. max - 255 characters.'
|
|
optional :replace,
|
|
type: { value: Boolean, message: 'admin.user.non_boolean_replace' },
|
|
default: true,
|
|
desc: 'When true label will be created if not exist'
|
|
end
|
|
post '/update' do
|
|
admin_authorize! :update, Label
|
|
|
|
declared_params = declared(params, include_missing: false)
|
|
|
|
target_user = User.find_by_uid(declared_params[:uid])
|
|
error!({ errors: ['admin.user.doesnt_exist'] }, 404) if target_user.nil?
|
|
|
|
if target_user.superadmin? && !current_user.superadmin?
|
|
error!({ errors: ['admin.user.superadmin_change'] }, 422)
|
|
end
|
|
|
|
label = Label.find_by_key_and_user_id_and_scope(declared_params[:key], target_user.id, declared_params[:scope])
|
|
|
|
if label.nil?
|
|
if declared_params[:replace]
|
|
label = Label.create(
|
|
user_id: target_user.id,
|
|
key: declared_params[:key],
|
|
value: declared_params[:value],
|
|
scope: declared_params[:scope],
|
|
description: declared_params[:description]
|
|
)
|
|
else
|
|
error!({ errors: ['admin.label.doesnt_exist'] }, 404)
|
|
end
|
|
else
|
|
label.update({ value: params[:value], description: params[:description] })
|
|
end
|
|
code_error!(label.errors.details, 422) if label.errors.any?
|
|
|
|
status 200
|
|
end
|
|
|
|
desc 'Update user label scope',
|
|
failure: [
|
|
{ code: 400, message: 'Required params are empty' },
|
|
{ code: 401, message: 'Invalid bearer token' },
|
|
{ code: 404, message: 'Record is not found' },
|
|
{ code: 422, message: 'Validation errors' }
|
|
],
|
|
success: { code: 200, message: 'Label was updated' }
|
|
params do
|
|
requires :uid,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'user uniq id'
|
|
requires :key,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'Label key.'
|
|
requires :scope,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'label key. [a-z0-9_-]+ should be used. Min - 3, max - 255 characters.'
|
|
optional :description,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'label description. [A-Za-z0-9_-] should be used. max - 255 characters.'
|
|
requires :value,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'Label value.'
|
|
end
|
|
put do
|
|
admin_authorize! :update, Label
|
|
|
|
declared_params = declared(params, include_missing: false)
|
|
|
|
target_user = User.find_by_uid(declared_params[:uid])
|
|
error!({ errors: ['admin.user.doesnt_exist'] }, 404) if target_user.nil?
|
|
|
|
if target_user.superadmin? && !current_user.superadmin?
|
|
error!({ errors: ['admin.user.superadmin_change'] }, 422)
|
|
end
|
|
|
|
label = Label.find_by_key_and_user_id_and_scope(declared_params[:key], target_user.id, declared_params[:scope])
|
|
|
|
error!({ errors: ['admin.label.doesnt_exist'] }, 404) if label.nil?
|
|
|
|
unless label.update({ value: params[:value], description: params[:description] }.compact)
|
|
code_error!(label.errors.details, 422)
|
|
end
|
|
status 200
|
|
end
|
|
|
|
desc 'Deletes label for user',
|
|
failure: [
|
|
{ code: 401, message: 'Invalid bearer token' }
|
|
],
|
|
success: { code: 200, message: 'Label was deleted' }
|
|
params do
|
|
requires :uid,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'user uniq id'
|
|
requires :key,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'label key. [a-z0-9_-]+ should be used. Min - 3, max - 255 characters.'
|
|
requires :scope,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'label key. [a-z0-9_-]+ should be used. Min - 3, max - 255 characters.'
|
|
end
|
|
delete do
|
|
admin_authorize! :destroy, Label
|
|
|
|
declared_params = declared(params, include_missing: false)
|
|
|
|
target_user = User.find_by_uid(params[:uid])
|
|
error!({ errors: ['admin.user.doesnt_exist'] }, 404) if target_user.nil?
|
|
|
|
if target_user.superadmin? && !current_user.superadmin?
|
|
error!({ errors: ['admin.user.superadmin_change'] }, 422)
|
|
end
|
|
|
|
label = Label.find_by_key_and_user_id_and_scope(declared_params[:key], target_user.id, declared_params[:scope])
|
|
|
|
error!({ errors: ['admin.label.doesnt_exist'] }, 404) if label.nil?
|
|
|
|
label.destroy
|
|
status 200
|
|
end
|
|
end
|
|
|
|
desc 'Returns user info',
|
|
failure: [
|
|
{ code: 401, message: 'Invalid bearer token' }
|
|
],
|
|
success: API::V2::Admin::Entities::UserWithKYC
|
|
params do
|
|
requires :uid,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'user uniq id'
|
|
end
|
|
get '/:uid' do
|
|
admin_authorize! :read, User
|
|
|
|
target_user = User.find_by_uid(params[:uid])
|
|
error!({ errors: ['admin.user.doesnt_exist'] }, 404) if target_user.nil?
|
|
|
|
present target_user, with: API::V2::Admin::Entities::UserWithKYC
|
|
end
|
|
|
|
desc "Deletes user's data storage record",
|
|
failure: [
|
|
{ code: 401, message: 'Invalid bearer token' }
|
|
],
|
|
success: API::V2::Admin::Entities::UserWithKYC
|
|
params do
|
|
requires :uid,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'user uniq id'
|
|
requires :title,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'data storage uniq title'
|
|
end
|
|
delete '/data_storage' do
|
|
admin_authorize! :destroy, User
|
|
|
|
target_user = User.find_by_uid(params[:uid])
|
|
error!({ errors: ['admin.user.doesnt_exist'] }, 404) if target_user.nil?
|
|
|
|
storage = target_user.data_storages.find_by_title(params[:title])
|
|
error!({ errors: ['admin.storage.doesnt_exist'] }, 404) if storage.nil?
|
|
|
|
target_user.labels.find_by(key: storage.title, scope: 'private')
|
|
storage.destroy
|
|
present target_user, with: API::V2::Admin::Entities::UserWithKYC
|
|
end
|
|
|
|
namespace :comments do
|
|
desc "Adds new user's comment",
|
|
failure: [
|
|
{ code: 401, message: 'Invalid bearer token' }
|
|
],
|
|
success: API::V2::Admin::Entities::UserWithKYC
|
|
params do
|
|
requires :uid,
|
|
type: String,
|
|
allow_blank: false,
|
|
desc: 'user uniq id'
|
|
requires :title,
|
|
type: String,
|
|
values: { value: -> (v){ v.length <= 64 }, message: 'admin.comments.title_too_long'},
|
|
allow_blank: false,
|
|
desc: 'comment uniq title'
|
|
requires :data,
|
|
type: String,
|
|
values: { value: -> (v){ v.length <= 65535 }, message: 'admin.comments.data_too_long'},
|
|
allow_blank: false,
|
|
desc: 'comment data'
|
|
end
|
|
post do
|
|
target_user = User.find_by_uid(params[:uid])
|
|
error!({ errors: ['admin.user.doesnt_exist'] }, 404) if target_user.nil?
|
|
|
|
comment = Comment.new(user_id: target_user.id,
|
|
data: params[:data],
|
|
title: params[:title],
|
|
author_uid: current_user[:uid])
|
|
|
|
code_error!(data_storage.errors.details, 422) unless comment.save
|
|
|
|
present target_user, with: API::V2::Admin::Entities::UserWithKYC
|
|
end
|
|
|
|
desc "Edit user's comment",
|
|
failure: [
|
|
{ code: 401, message: 'Invalid bearer token' }
|
|
],
|
|
success: API::V2::Admin::Entities::UserWithKYC
|
|
params do
|
|
requires :id,
|
|
type: Integer,
|
|
desc: 'comment uniq id'
|
|
optional :title,
|
|
type: String,
|
|
values: { value: -> (v){ v.length <= 64 }, message: 'admin.comments.title_too_long'},
|
|
allow_blank: false,
|
|
desc: 'comment title'
|
|
optional :data,
|
|
type: String,
|
|
values: { value: -> (v){ v.length <= 65535 }, message: 'admin.comments.data_too_long'},
|
|
allow_blank: false,
|
|
desc: 'comment data'
|
|
end
|
|
put do
|
|
comment = Comment.find(params[:id])
|
|
error!({ errors: ['admin.comment.doesnt_exist'] }, 404) if comment.nil?
|
|
|
|
code_error!(comment.errors.details, 422) unless comment.update(params.slice(:data, :title))
|
|
|
|
present comment.user, with: API::V2::Admin::Entities::UserWithKYC
|
|
end
|
|
|
|
desc "Delete user's comment",
|
|
failure: [
|
|
{ code: 401, message: 'Invalid bearer token' }
|
|
],
|
|
success: API::V2::Admin::Entities::UserWithKYC
|
|
params do
|
|
requires :id,
|
|
type: Integer,
|
|
desc: 'comment uniq id'
|
|
end
|
|
delete do
|
|
comment = Comment.find(params[:id])
|
|
error!({ errors: ['admin.comment.doesnt_exist'] }, 404) if comment.nil?
|
|
|
|
code_error!(comment.errors.details, 422) unless comment.destroy
|
|
|
|
present comment.user, with: API::V2::Admin::Entities::UserWithKYC
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|