active_stix 0.1.21

data/app/controllers/active_stix/relationships_controller.rb

@@ -0,0 +1,62 @@
+require_dependency "active_stix/application_controller"
+
+module ActiveStix
+  class RelationshipsController < ApplicationController
+    before_action :set_relationship, only: [:show, :edit, :update, :destroy]
+
+    # GET /relationships
+    def index
+      @relationships = Relationship.all
+    end
+
+    # GET /relationships/1
+    def show
+    end
+
+    # GET /relationships/new
+    def new
+      @relationship = Relationship.new
+    end
+
+    # GET /relationships/1/edit
+    def edit
+    end
+
+    # POST /relationships
+    def create
+      @relationship = Relationship.new(relationship_params)
+
+      if @relationship.save
+        redirect_to @relationship, notice: 'Relationship was successfully created.'
+      else
+        render :new
+      end
+    end
+
+    # PATCH/PUT /relationships/1
+    def update
+      if @relationship.update(relationship_params)
+        redirect_to @relationship, notice: 'Relationship was successfully updated.'
+      else
+        render :edit
+      end
+    end
+
+    # DELETE /relationships/1
+    def destroy
+      @relationship.destroy
+      redirect_to relationships_url, notice: 'Relationship was successfully destroyed.'
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_relationship
+        @relationship = Relationship.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def relationship_params
+        params.require(:relationship).permit(:relationship_type, :description, :source_ref, :target_ref, :source_type, :target_type, :active_stix_id, :object_marking_refs)
+      end
+  end
+end

data/app/controllers/active_stix/reports_controller.rb

@@ -0,0 +1,62 @@
+require_dependency "active_stix/application_controller"
+
+module ActiveStix
+  class ReportsController < ApplicationController
+    before_action :set_report, only: [:show, :edit, :update, :destroy]
+
+    # GET /reports
+    def index
+      @reports = Report.all
+    end
+
+    # GET /reports/1
+    def show
+    end
+
+    # GET /reports/new
+    def new
+      @report = Report.new
+    end
+
+    # GET /reports/1/edit
+    def edit
+    end
+
+    # POST /reports
+    def create
+      @report = Report.new(report_params)
+
+      if @report.save
+        redirect_to @report, notice: 'Report was successfully created.'
+      else
+        render :new
+      end
+    end
+
+    # PATCH/PUT /reports/1
+    def update
+      if @report.update(report_params)
+        redirect_to @report, notice: 'Report was successfully updated.'
+      else
+        render :edit
+      end
+    end
+
+    # DELETE /reports/1
+    def destroy
+      @report.destroy
+      redirect_to reports_url, notice: 'Report was successfully destroyed.'
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_report
+        @report = Report.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def report_params
+        params.require(:report).permit(:created_by_ref, :revoked, :name, :description, :published, :active_stix_id)
+      end
+  end
+end

data/app/controllers/active_stix/threat_actors_controller.rb

@@ -0,0 +1,75 @@
+class ActiveStix::ThreatActorsController < ApplicationController
+  before_action :set_stix_threat_actor, only: [:show, :edit, :update, :destroy]
+
+  # GET /stix/threat_actors
+  # GET /stix/threat_actors.json
+  def index
+    @threat_actors = ActiveStix::ThreatActor.all
+  end
+
+  # GET /stix/threat_actors/1
+  # GET /stix/threat_actors/1.json
+  def show
+  end
+
+  # GET /stix/threat_actors/new
+  def new
+    @threat_actor = ActiveStix::ThreatActor.new
+  end
+
+  # GET /stix/threat_actors/1/edit
+  def edit
+  end
+
+  # POST /stix/threat_actors
+  # POST /stix/threat_actors.json
+  def create
+    @threat_actor = ActiveStix::ThreatActor.new(stix_threat_actor_params)
+
+    respond_to do |format|
+      if @threat_actor.save
+        format.html { redirect_to @threat_actor, notice: 'Threat actor was successfully created.' }
+        format.json { render :show, status: :created, location: @threat_actor }
+      else
+        format.html { render :new }
+        format.json { render json: @threat_actor.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PATCH/PUT /stix/threat_actors/1
+  # PATCH/PUT /stix/threat_actors/1.json
+  def update
+    respond_to do |format|
+      if @threat_actor.update(stix_threat_actor_params)
+        format.html { redirect_to @threat_actor, notice: 'Threat actor was successfully updated.' }
+        format.json { render :show, status: :ok, location: @threat_actor }
+      else
+        format.html { render :edit }
+        format.json { render json: @threat_actor.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /stix/threat_actors/1
+  # DELETE /stix/threat_actors/1.json
+  def destroy
+    @threat_actor.destroy
+    respond_to do |format|
+      format.html { redirect_to stix_threat_actors_url, notice: 'Threat actor was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_stix_threat_actor
+      @threat_actor = ActiveStix::ThreatActor.find(params[:id])
+    end
+
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def stix_threat_actor_params
+      params.require(:threat_actor).permit(:name, :description)
+    end
+end

data/app/controllers/active_stix/tools_controller.rb

@@ -0,0 +1,62 @@
+require_dependency "active_stix/application_controller"
+
+module ActiveStix
+  class ToolsController < ApplicationController
+    before_action :set_tool, only: [:show, :edit, :update, :destroy]
+
+    # GET /tools
+    def index
+      @tools = Tool.all
+    end
+
+    # GET /tools/1
+    def show
+    end
+
+    # GET /tools/new
+    def new
+      @tool = Tool.new
+    end
+
+    # GET /tools/1/edit
+    def edit
+    end
+
+    # POST /tools
+    def create
+      @tool = Tool.new(tool_params)
+
+      if @tool.save
+        redirect_to @tool, notice: 'Tool was successfully created.'
+      else
+        render :new
+      end
+    end
+
+    # PATCH/PUT /tools/1
+    def update
+      if @tool.update(tool_params)
+        redirect_to @tool, notice: 'Tool was successfully updated.'
+      else
+        render :edit
+      end
+    end
+
+    # DELETE /tools/1
+    def destroy
+      @tool.destroy
+      redirect_to tools_url, notice: 'Tool was successfully destroyed.'
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_tool
+        @tool = Tool.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def tool_params
+        params.require(:tool).permit(:active_stix_id, :name, :description, :created_by_ref)
+      end
+  end
+end

data/app/controllers/active_stix/urls_controller.rb

@@ -0,0 +1,62 @@
+require_dependency "active_stix/application_controller"
+
+module ActiveStix
+  class UrlsController < ApplicationController
+    before_action :set_url, only: [:show, :edit, :update, :destroy]
+
+    # GET /urls
+    def index
+      @urls = Url.all
+    end
+
+    # GET /urls/1
+    def show
+    end
+
+    # GET /urls/new
+    def new
+      @url = Url.new
+    end
+
+    # GET /urls/1/edit
+    def edit
+    end
+
+    # POST /urls
+    def create
+      @url = Url.new(url_params)
+
+      if @url.save
+        redirect_to @url, notice: 'Url was successfully created.'
+      else
+        render :new
+      end
+    end
+
+    # PATCH/PUT /urls/1
+    def update
+      if @url.update(url_params)
+        redirect_to @url, notice: 'Url was successfully updated.'
+      else
+        render :edit
+      end
+    end
+
+    # DELETE /urls/1
+    def destroy
+      @url.destroy
+      redirect_to urls_url, notice: 'Url was successfully destroyed.'
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_url
+        @url = Url.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def url_params
+        params.require(:url).permit(:value)
+      end
+  end
+end

data/app/controllers/active_stix/user_accounts_controller.rb

@@ -0,0 +1,74 @@
+class ActiveStix::UserAccountsController < ApplicationController
+  before_action :set_stix_user_account, only: [:show, :edit, :update, :destroy]
+
+  # GET /stix/user_accounts
+  # GET /stix/user_accounts.json
+  def index
+    @user_accounts = ActiveStix::UserAccount.all
+  end
+
+  # GET /stix/user_accounts/1
+  # GET /stix/user_accounts/1.json
+  def show
+  end
+
+  # GET /stix/user_accounts/new
+  def new
+    @user_account = ActiveStix::UserAccount.new
+  end
+
+  # GET /stix/user_accounts/1/edit
+  def edit
+  end
+
+  # POST /stix/user_accounts
+  # POST /stix/user_accounts.json
+  def create
+    @user_account = ActiveStix::UserAccount.new(stix_user_account_params)
+
+    respond_to do |format|
+      if @user_account.save
+        format.html { redirect_to @user_account, notice: 'User account was successfully created.' }
+        format.json { render :show, status: :created, location: @user_account }
+      else
+        format.html { render :new }
+        format.json { render json: @user_account.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PATCH/PUT /stix/user_accounts/1
+  # PATCH/PUT /stix/user_accounts/1.json
+  def update
+    respond_to do |format|
+      if @user_account.update(stix_user_account_params)
+        format.html { redirect_to @user_account, notice: 'User account was successfully updated.' }
+        format.json { render :show, status: :ok, location: @user_account }
+      else
+        format.html { render :edit }
+        format.json { render json: @user_account.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /stix/user_accounts/1
+  # DELETE /stix/user_accounts/1.json
+  def destroy
+    @user_account.destroy
+    respond_to do |format|
+      format.html { redirect_to stix_user_accounts_url, notice: 'User account was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_stix_user_account
+      @user_account = ActiveStix::UserAccount.find(params[:id])
+    end
+
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def stix_user_account_params
+      params.require(:user_account).permit(:user_id, :account_login, :account_type, :display_name, :is_service_account, :is_privileged, :can_escalate_privs, :is_disabled, :account_created, :account_expires, :password_last_changed, :account_first_login, :account_last_login)
+    end
+end

data/app/controllers/active_stix/users_controller.rb

@@ -0,0 +1,62 @@
+require_dependency "active_stix/application_controller"
+
+module ActiveStix
+  class UsersController < ApplicationController
+    before_action :set_user, only: [:show, :edit, :update, :destroy]
+
+    # GET /users
+    def index
+      @users = User.all
+    end
+
+    # GET /users/1
+    def show
+    end
+
+    # GET /users/new
+    def new
+      @user = User.new
+    end
+
+    # GET /users/1/edit
+    def edit
+    end
+
+    # POST /users
+    def create
+      @user = User.new(user_params)
+
+      if @user.save
+        redirect_to @user, notice: 'User was successfully created.'
+      else
+        render :new
+      end
+    end
+
+    # PATCH/PUT /users/1
+    def update
+      if @user.update(user_params)
+        redirect_to @user, notice: 'User was successfully updated.'
+      else
+        render :edit
+      end
+    end
+
+    # DELETE /users/1
+    def destroy
+      @user.destroy
+      redirect_to users_url, notice: 'User was successfully destroyed.'
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_user
+        @user = User.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def user_params
+        params.require(:user).permit(:account, :user_id, :account_login, :account_type, :display_name, :is_service_account, :is_privileged, :can_escalate_privs, :is_disabled, :account_created, :account_expires, :password_last_changed, :account_first_login, :account_last_login)
+      end
+  end
+end