active_stix 0.1.21

data/app/controllers/active_stix/kill_chain_phases_controller.rb

@@ -0,0 +1,62 @@
+require_dependency "active_stix/application_controller"
+
+module ActiveStix
+  class KillChainPhasesController < ApplicationController
+    before_action :set_kill_chain_phase, only: [:show, :edit, :update, :destroy]
+
+    # GET /kill_chain_phases
+    def index
+      @kill_chain_phases = KillChainPhase.all
+    end
+
+    # GET /kill_chain_phases/1
+    def show
+    end
+
+    # GET /kill_chain_phases/new
+    def new
+      @kill_chain_phase = KillChainPhase.new
+    end
+
+    # GET /kill_chain_phases/1/edit
+    def edit
+    end
+
+    # POST /kill_chain_phases
+    def create
+      @kill_chain_phase = KillChainPhase.new(kill_chain_phase_params)
+
+      if @kill_chain_phase.save
+        redirect_to @kill_chain_phase, notice: 'Kill chain phase was successfully created.'
+      else
+        render :new
+      end
+    end
+
+    # PATCH/PUT /kill_chain_phases/1
+    def update
+      if @kill_chain_phase.update(kill_chain_phase_params)
+        redirect_to @kill_chain_phase, notice: 'Kill chain phase was successfully updated.'
+      else
+        render :edit
+      end
+    end
+
+    # DELETE /kill_chain_phases/1
+    def destroy
+      @kill_chain_phase.destroy
+      redirect_to kill_chain_phases_url, notice: 'Kill chain phase was successfully destroyed.'
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_kill_chain_phase
+        @kill_chain_phase = KillChainPhase.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def kill_chain_phase_params
+        params.require(:kill_chain_phase).permit(:attack_pattern_ref, :phase_id)
+      end
+  end
+end

data/app/controllers/active_stix/kill_chains_controller.rb

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

data/app/controllers/active_stix/malwares_controller.rb

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

data/app/controllers/active_stix/marking_definitions_controller.rb

@@ -0,0 +1,62 @@
+require_dependency "active_stix/application_controller"
+
+module ActiveStix
+  class MarkingDefinitionsController < ApplicationController
+    before_action :set_marking_definition, only: [:show, :edit, :update, :destroy]
+
+    # GET /marking_definitions
+    def index
+      @marking_definitions = MarkingDefinition.all
+    end
+
+    # GET /marking_definitions/1
+    def show
+    end
+
+    # GET /marking_definitions/new
+    def new
+      @marking_definition = MarkingDefinition.new
+    end
+
+    # GET /marking_definitions/1/edit
+    def edit
+    end
+
+    # POST /marking_definitions
+    def create
+      @marking_definition = MarkingDefinition.new(marking_definition_params)
+
+      if @marking_definition.save
+        redirect_to @marking_definition, notice: 'Marking definition was successfully created.'
+      else
+        render :new
+      end
+    end
+
+    # PATCH/PUT /marking_definitions/1
+    def update
+      if @marking_definition.update(marking_definition_params)
+        redirect_to @marking_definition, notice: 'Marking definition was successfully updated.'
+      else
+        render :edit
+      end
+    end
+
+    # DELETE /marking_definitions/1
+    def destroy
+      @marking_definition.destroy
+      redirect_to marking_definitions_url, notice: 'Marking definition was successfully destroyed.'
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_marking_definition
+        @marking_definition = MarkingDefinition.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def marking_definition_params
+        params.require(:marking_definition).permit(:active_stix_id, :definition_type, :definition, :relationship_ref)
+      end
+  end
+end

data/app/controllers/active_stix/observed_data_controller.rb

@@ -0,0 +1,62 @@
+require_dependency "active_stix/application_controller"
+
+module ActiveStix
+  class ObservedDataController < ApplicationController
+    before_action :set_observed_datum, only: [:show, :edit, :update, :destroy]
+
+    # GET /observed_data
+    def index
+      @observed_data = ObservedDatum.all
+    end
+
+    # GET /observed_data/1
+    def show
+    end
+
+    # GET /observed_data/new
+    def new
+      @observed_datum = ObservedDatum.new
+    end
+
+    # GET /observed_data/1/edit
+    def edit
+    end
+
+    # POST /observed_data
+    def create
+      @observed_datum = ObservedDatum.new(observed_datum_params)
+
+      if @observed_datum.save
+        redirect_to @observed_datum, notice: 'Observed datum was successfully created.'
+      else
+        render :new
+      end
+    end
+
+    # PATCH/PUT /observed_data/1
+    def update
+      if @observed_datum.update(observed_datum_params)
+        redirect_to @observed_datum, notice: 'Observed datum was successfully updated.'
+      else
+        render :edit
+      end
+    end
+
+    # DELETE /observed_data/1
+    def destroy
+      @observed_datum.destroy
+      redirect_to observed_data_url, notice: 'Observed datum was successfully destroyed.'
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_observed_datum
+        @observed_datum = ObservedDatum.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def observed_datum_params
+        params.require(:observed_datum).permit(:active_stix_id, :first_observed_datetime, :last_observed, :number_observed)
+      end
+  end
+end

data/app/controllers/active_stix/open_vocabularies_controller.rb

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

data/app/controllers/active_stix/phases_controller.rb

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

data/app/controllers/active_stix/recipients_controller.rb

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