Risk many to many logic

risks-many-to-many.rb

module ObserverInterface
	def update(observable)
		raise ImplementationError # Class ZBC not implemented method xyz
	end
end

class Risk
	include ObserverInterface
	include RiskInterface
end

class DiseaseRisk < Risk


	def eligible?
		@pregnancy.diseases.each do |disease|
			if disease.slug == self.disease_slug
				return true
			end
		end

		false
	end

	def update(observable) # DiseaseRiskObservable
		if observable.instance_of?(DiseaseRiskObservable)
			add_risk if eligible?
		end
	end

	def add_risk
		obvservable.clasification.send(:riskable) << Risk.find(slug: slug)
	end
end

class AsthmaRisk < DiseaseRisk
	self.risk_slug = :asma
	self.disease_slug = :asma
	self.riskable = :pregnancy
end

class HivRisk < DiseaseRisk
	self.riskable = :mother
end

class RiskClasification
	def initialize
		@mother = Array.new
		@pregnancy = Array.new
		@anc = Array.new
	end
end

class DiseaseRiskObservable

	attr_accessor :pregnancy

	def initialize
		@clasification = RiskClasification.new
	end

	def observers=(obsrvs)
		@observers << obsrvs
	end

	# def pregnancy=(p)
	# 	@pregnancy = p
	# end

	# pregnancy_risks = Array.new
	# mother_risks = Array.new

	def notify

		@observers.each do |observer|
			observer.update(self)
		end

		pregnancy_risks = @risk_clasification.pregnancy
		mother_risks = @risk_clasification.mother

		#pregnancy_risks = generate_risk :pregnancy
		#mother_risks = generate_risk :mother

		pr_sync = []
		pregnancy_risks.each do |pr|
			pr_sync[pr.id] = {child_id: @anc.id}
		end



		@pregnancy.risks.sync pr_sync#[1: {child_id: @anc.id},2: {child_id: @anc.id},3: {child_id: @anc.id}]

		 # x = Hash[[risk.id, @pregnancy.id], []]

		@mother.risks.sync x
		[
			9: {child_id: @pregancy.id},
			8: {child_id: @pregancy.id},
			4: {child_id: @pregancy.id}
		]
	end

	# def generate_risk(type)
	# 	risks = []

	# 	@observers.each do |observer|
	# 		observer = observer.to_s.camelize + 'Risk'
	# 		observer = observer.constantize
	# 		risk_observer = observer.new # AsthmaRisk.new
	# 		# if risk_observer.eligible?
	# 		risks << risk_observer.risk if (risk.riskable == type && risk_observer.eligible?)
	# 		# end
	# 	end

	# end
end

dro = DiseaseRiskObservable.new
dro.observers = [:asthma, :hiv]
dro.pregnancy = pregnancy
dro.notify

risks-single.rb

class TooClose < Risk

	self.riskable = :pregnancy

	def eligible?
		@pregnancy.hpht - @pregnancy.last_maternity_date > 2
	end

end

class PregnancyObservable
	def observers=(obsrvs)
		@observers << obsrvs
	end

	def notify
		@observers.each do |observer|
			observer.update(self)
		end

		@pregnancy.risks.sync p_risks
	end
end


class Pregnancy < ActiveRecord::Base

	after_save :calculate_risk

	def calcualte_risk

		dro = PregnancyObservable.new self
		dro.observers = [:abortus, :too_often, :too_close]
		# dro.observable = self
		dro.notify
	end