model for virtual market of knowledge

readme.txt

This is Model for Virtual Market of Knowledge

course.py

class Course:
	def __init__(self,course_id,course_title,course_price,course_level_begin,course_level_end):
		self.course_id = course_id
		self.course_title = course_title
		self.course_price = course_price
		self.reputation = 0
		self.school = ''
		self.course_pre = 0
		self.course_post = 0
		self.course_level_begin=course_level_begin
		self.course_level_end=course_level_end
		self.course_seller = None
	def __repr__(self):
		return self.course_id
	def set_course_level(self,course_level_begin,course_level_end):
		self.course_level_begin = course_level_begin
		self.course_level_end = course_level_end
	def get_course_level_begin(self):
		return self.course_level_begin
	def get_course_level_end(self):
		return self.course_level_end
	def get_id(self):
		return self.course_id
	def get_course_title(self):
		return self.course_title
	def get_course_id(self):
		return self.course_id
	def set_course_title(self,course_title):
		self.course_title = course_title
	def set_price(self,price):
		self.course_price = price
	def get_price(self):
		return self.course_price
	def set_seller(self,seller_instance):
		self.course_seller = seller_instance

class CourseSequence:
	def __init__(self,course_instance_list):
		self.courses = course_instance_list
		self.seller = None
	def set_seller(self,seller_instance):
		self.seller = seller_instance
	def get_seller(self):
		return self.seller
	def get_course_sequence_string(self):
		xstr = ''
		for x in self.courses:
			xstr=xstr+'->'+x.get_course_id()+'({},{})'.format(x.get_course_level_begin(),x.get_course_level_end())
		return xstr
	def get_total_price(self):
		total = 0
		for x in self.courses:
			total = total+ x.get_price()
		return total

class CourseGraph:
	def __init__(self,graph):
		self.graph = graph
	def find_all_path(self, start, end, path=None):
		self.start = start
		self.end = end
		_path = path if path else []
		_path += [self.start]
		if self.start == self.end:
			return [_path]
		if self.start not in self.graph:
			return []
		paths = []
		for node in self.graph[self.start]:
			if node not in _path:
				newpaths = self.find_all_path(node, self.end, _path[:])
				for newpath in newpaths:
					paths.append(newpath)
		return paths


class Seller:
	def __init__(self, name):
		self.name = name
		self.reputation = 0
		self.courses = []
		self.course_graph={}
		self.course_def={}
		for x in range(1,11):
			self.course_graph[x]=[]
	def get_name(self):
		return self.name
	def add_course(self, course_instance):
		x=self.course_graph[course_instance.get_course_level_begin()]
		x.append(course_instance.get_course_level_end())
		self.course_def[(course_instance.get_course_level_begin(),course_instance.get_course_level_end())]=course_instance
		course_instance.set_seller(self)
		self.courses.append(course_instance)
	def print_graph(self):
		print self.course_graph
	def get_course_sequence(self,level_begin,level_end):
		seq_offer = []
		graph = CourseGraph(self.course_graph)
		#print self.course_graph
		#print self.course_def
		seq_asli = graph.find_all_path(start=level_begin,end=level_end)
		for s in seq_asli:
			seq=[]
			for n in range(0,len(s)):
				try:
					b_begin = s[n]
					b_end = s[n+1]
					seq.append(self.course_def[(b_begin,b_end)])
				except IndexError:
					break
			CS=CourseSequence(seq)
			CS.set_seller(self)
			seq_offer.append(CS)
		return seq_offer
	def get_courses(self):
		return self.courses
	def set_reputation(self,rep):
		self.reputation = rep
	def get_reputation(self):
		return self.reputation

class Student:
	def __init__(self,name,initial_level,target_level,initial_budget, condition):
		self.name = name
		self.level = initial_level
		self.target_level = target_level
		self.budget = initial_budget
		self.condition = condition
		self.course_catalog = 0
	def get_name(self):
		return self.name
	def get_target_level(self):
		return self.target_level
	def set_current_level(self,level):
		self.level = level
	def get_current_level(self):
		return self.level
	def set_budget(self,budget):
		self.budget = budget
	def get_current_budget(self):
		return self.budget
		
		
class VirtualMarket:
	def __init__(self):
		self.seller = []
	def add_seller(self,seller_instance):
		self.seller.append(seller_instance)
	def search_capability(self,level_begin,level_end):
		search_result=[]
		for seller in self.seller:
			search_result.append(seller.get_course_sequence(level_begin,level_end))			
		return search_result

class View:
	def __init__(self,market_instance):
		self.market = market_instance
	def show_search_capability(self,level_begin,level_end):
		print 
		print "Searching for Level {} to {}" .  format(level_begin,level_end)
		for result in self.market.search_capability(level_begin,level_end):
			for cs in result:
				print "From {}, Courses: {}, Total Price {}" . format(cs.get_seller().get_name(),cs.get_course_sequence_string(),cs.get_total_price())
			
				

if __name__=='__main__':
	print "Set-up..."
	
	ITS = Seller('Institut Teknologi Sepuluh Nopember')
	ITS.add_course(Course('ITSX001','Course X001 of ITS',500,1,3))
	ITS.add_course(Course('ITSX002','Course X002 of ITS',20,3,7))
	ITS.add_course(Course('ITSX003','Course X003 of ITS',400,1,10))
	ITS.add_course(Course('ITSX004','Course X004 of ITS',20,1,5))
	ITS.add_course(Course('ITSX005','Course X005 of ITS',200,5,10))
	ITS.add_course(Course('ITSX006','Course X006 of ITS',200,7,10))

	UI = Seller('University of Indonesia')
	UI.add_course(Course('UI 101 ','Course 101 of UI',200,1,3))
	UI.add_course(Course('UI 102','Course 102 of UI',230,3,7))
	UI.add_course(Course('UI 103','Course 103 of UI',40,1,10))

	VMK = VirtualMarket()
	VMK.add_seller(ITS)
	VMK.add_seller(UI)
	
	
	VI = View(VMK)
	VI.show_search_capability(1,10)
	VI.show_search_capability(1,7)

ITS adalah sebuah seller, yang mempunyai beberapa courses dengan kemampuan tertentu dan juga harga tertentu
UI juga demikian,
Virtual Market akan menyatukan seller seller tersebut. Masing-masing seller akan mempunyai jaringan course yang terhubung berdasarkan level kemampuan awal dan akhir.
Oleh karena itu dari virtual market itu kita bisa dapatkan course course mana saja yang bisa memenuhi capability tertentu sesuai dengan yang di cari

Hasil outputnya adalah seperti ini

Set-up...

Searching for Level 1 to 10
From Institut Teknologi Sepuluh Nopember, Courses: ->ITSX001(1,3)->ITSX002(3,7)->ITSX006(7,10), Total Price 720
From Institut Teknologi Sepuluh Nopember, Courses: ->ITSX003(1,10), Total Price 400
From Institut Teknologi Sepuluh Nopember, Courses: ->ITSX004(1,5)->ITSX005(5,10), Total Price 220
From University of Indonesia, Courses: ->UI 103(1,10), Total Price 40

Searching for Level 1 to 7
From Institut Teknologi Sepuluh Nopember, Courses: ->ITSX001(1,3)->ITSX002(3,7), Total Price 520
From University of Indonesia, Courses: ->UI 101 (1,3)->UI 102(3,7), Total Price 430

course sequnce ditarik ke market, agar graph bisa lebih global

test tambah komentar