Anmeldung und Login über benutzerdefinierte API - Wird es richtig funktionieren?

Entwickler
1

In unserem Fall müssen wir Discourse nur als Backend verwenden (plus oder weniger wie ein CMS).

Ich habe die Routen für die Registrierung und Anmeldung wie folgt freigegeben:

skip_before_action :redirect_to_login_if_required, raise: false
skip_before_action :verify_authenticity_token, raise: false

… und die Routen in api_parameter_allowed? erlaubt. In der finalen Version werde ich eine Art Salt hinzufügen, um ein wenig mehr Sicherheit zu gewährleisten, aber dies ist derzeit nur ein Entwurf.

… und habe den folgenden Code verwendet.

Alles, was ich wissen möchte, ist, ob ich etwas übersehen habe. In Zukunft werden wir uns wahrscheinlich mit Google, vielleicht auch mit Apple, anmelden. Dieser Ablauf würde es mir ermöglichen, bei der Registrierung und Anmeldung per E-Mail überhaupt keinen Browser zu öffnen.

2

Ich habe herausgefunden, wie man die Registrierung und Anmeldung ausschließlich über die API durchführt, und hoffe, dass alles in Ordnung ist.

So erstelle ich einen Benutzer:

      normalized_username = User.normalize_username(username)
    rescue
      normalized_username = nil
    end
    raise PluginError.new(:invalid_signup_username) if !normalized_username.present? || User.username_exists?(normalized_username) || User.reserved_username?(normalized_username)

    # Versuche es so
    raise PluginError.new(:invalid_signup_email) if (existing_user = User.find_by_email(email))

    begin
      new_user = User.new
      new_user.name = first_name
      new_user.email = email
      new_user.password = password
      new_user.username = username
      new_user.active = false
      new_user.approved = true
      new_user.approved_by_id = -1
      new_user.approved_at = DateTime.now

      new_user.password_required!

      new_user.save

      new_user.email_tokens.create(email: email) unless new_user.email_tokens.active.exists?
      if (email_token = new_user.email_tokens.active.where(email: email)&.first)
        EmailToken.confirm(email_token.token, skip_reviewable: true)
      end

      new_user.update!(active: true)
    rescue => e
      raise e
    end

So melde ich einen Benutzer an:

new_user = self.class.commit_user_to_db(first_name, email, password, username)

    raise PluginError.new(:error_creating_user_discourse) unless new_user.present? && new_user.is_a?(User) && new_user.approved?

    user_api_key = UserApiKey.create!(
      application_name: "#{application_name}-v#{version}",
      client_id: client_id,
      user_id: new_user.id,
      push_url: "https://api.discourse.org/api/publish_#{platform === Constants::PLATFORMS[:ios] ? 'ios' : ''}#{platform === Constants::PLATFORMS[:android] ? 'android' : ''}",
      scopes: %w[notifications session_info read write message_bus push]
    )

Ich erhalte den Benutzer-API-Schlüssel wie folgt:

    email = params[:email]&.to_s
    password = params[:password]&.to_s

    return render json: PluginError.new(:invalid_login_email) unless email.present?
    return render json: PluginError.new(:invalid_login_password) unless password.present?

    user = User.joins(:user_emails).where({ user_emails: { email: email } })&.first
    return render json: PluginError.new(:invalid_login_email) unless user.present?

    return render json: PluginError.new(:invalid_login_password) unless user.confirm_password?(password)

    # Löschen aller alten Schlüssel für diese client_id
    UserApiKey.where(user_id: user.id, client_id: client_id).destroy_all

    user_api_key = UserApiKey.create!(
      application_name: "#{application_name}-v#{version}",
      client_id: client_id,
      user_id: user.id,
      push_url: "https://api.discourse.org/api/publish_#{platform === Constants::PLATFORMS[:ios] ? 'ios' : ''}#{platform === Constants::PLATFORMS[:android] ? 'android' : ''}",
      scopes: %w[notifications session_info read write message_bus push]
    )

Ist dies aus Discourse-Sicht in Ordnung?
Unsere Benutzer werden die Website niemals besuchen, und wir möchten sie überall vor ihr verbergen.