def rebroadcast(collection, testing_mode=False):
"""
Rebroadcast the collection to the Main Channel
:param collection: the collection object
:return:
"""
#Connect to bitmessage and create a temporary address
bitmessage = Bitmessage()
from_address = bitmessage.create_address("Rebroadcast", random=True)
collection.address = from_address
#Connect to controller and rebroadcast
controller = Controller()
print("Rebroadcasting collection: " + collection.title)
if testing_mode:
success = controller.publish_collection(collection, from_address,
from_address)
else:
success = controller.publish_collection(collection,
MAIN_CHANNEL_ADDRESS,
from_address)
if not success:
return False
return True
def main():
parser = ArgumentParser(
description=
'Jezyki obietkowe - zadanie 2. Celem zadania bylo stworzenie '
'symulacji automatu komorkowego "Game of Life". W kontrolerze '
'zdefiniowano parametry NUM_ROWS, NUM_COLS, SIZE_OF_CELL '
'oznaczajace kolejno liczbe wierszy, liczbe kolumn oraz wielkosc komorki '
'uzywanej w grze. Zaleca sie modyfikowac te wartosci aby uzyskac '
'mniejsza/wieksza plansze z uwzglednieniem warunku, '
'ze okno gry ma wielkosc 500x500 px. Domyslnie ustawiono 50|50|10.')
parser.add_argument(
'--entry_point',
dest='entry_point',
type=str,
choices=['glider', 'random'],
default='random',
help=
'Ustaw glider jesli chcesz sprawdzic dzialanie typowego glidera z gry w zycie.'
' Domyslnie random.')
args = parser.parse_args()
entry_point = args.entry_point # glider | random
cnt = Controller()
cnt.app(entry_point)
def main():
"""main.
"""
ctrlr = Controller(None, None, CYSMenu("chess yo self"), None)
ctrlr.start()
return 0
def __init__(self, app, service, key):
Controller.__init__(self, 'player', __name__)
self.app = app
self.service = service
app.secret_key = key
self.player_count = 0
self.game_started = False
self.starter = threading.Timer(40, self.start_game)
self.starter.start()
def connect_button_handler(
self, event): # wxGlade: ControllerConnectDialog.<event_handler>
controller = wx.App.Get()
c = Controller(self.ports[self.port_listbox.GetSelection()].device,
controller, self.c_num)
c.start()
print(controller.controller_list)
self.Close(event)
def publish_collection(address_password, collection_address):
bitmessage_connection = Bitmessage()
address = bitmessage_connection.create_address(address_password)
collection = cache.get_collection_with_address(collection_address)
if collection is not None:
collection_handler = Controller()
collection_handler.publish_collection(collection, config.MAIN_CHANNEL_ADDRESS, address)
print ("Collection published successfully!")
else:
print ("Collection not found in local cache.")
def __init__(self, app, service, ruler):
Controller.__init__(self, 'play', __name__)
self.app = app
self.game = service
self.verifier = ruler
# this is how we will deal with turn time-outs
# every time a valid request is made, we will reset this timer
self.timeout_master = threading.Timer(3, self.player_timeout)
self.first_pass = False # we need this to pad the first players response. TODO: find something cleaner?
self.timeout_master.start()
def start():
controller = Controller()
controller.view.print_instructions()
choice = ''
while choice != "Q":
try:
choice = input().upper()
except KeyboardInterrupt:
sys.exit()
controller.handle_input(choice, list(item_table.items)[0].id)
def loadImage():
if request.files:
image = request.files["image"]
json = request.files["json"]
filename_ext = image.filename.rsplit(".", 1)
ext = filename_ext[1]
filename = filename_ext[0]
if filename_ext[1].upper() in Config.EXTENSIONSALLOWED:
Controller.loadImage(image, json, filename, ext)
return redirect(url_for("upload"), code=302)
class CarregaCamadas:
def __init__(self, iface):
loadLayersIconButton = LoadLayersIconButton(iface)
loadLayersInterface = LoadLayersInterface()
loadLayersModel = LoadLayers(iface)
self.controller = Controller(loadLayersModel, loadLayersIconButton, loadLayersInterface)
def initGui(self):
self.controller.runCommand('open loadLayersIconButton', 'True')
def unload(self):
self.controller.runCommand('open loadLayersIconButton', 'False')
class Main:
def __init__(self, iface):
view1 = IconButtonPtoControl(iface)
view2 = InterfacePtoControl(iface)
model = DocumentationPtoControl(iface)
self.controller = Controller(model, view1, view2)
def initGui(self):
self.controller.runCommand('add button', 'True')
def unload(self):
self.controller.runCommand('add button', 'False')
class CarregaCamadas:
def __init__(self, iface):
loadLayersIconButton = LoadLayersIconButton(iface)
loadLayersInterface = LoadLayersInterface()
loadLayersModel = LoadLayers(iface)
self.controller = Controller(loadLayersModel, loadLayersIconButton,
loadLayersInterface)
def initGui(self):
self.controller.runCommand('open loadLayersIconButton', 'True')
def unload(self):
self.controller.runCommand('open loadLayersIconButton', 'False')
def setUp(self):
self.controller = Controller()
self.cache = self.controller.cache
self.address = 'ffafaf'
coll_address = str(uuid.uuid1())
doc_hash_1 = str(uuid.uuid1())
doc_hash_2 = str(uuid.uuid1())
doc_hash_3 = str(uuid.uuid1())
self.test_collection_evil = Collection(
title="Test multiple33333",
description="This is a collection! with multiple docs222",
address=self.address,
btc="123456789",
keywords=[
Keyword(name="Keyword A", id=1199),
Keyword(name="Keyword c", id=1214),
],
documents=[
Document(
description="Test document Z",
hash="zzzzzzzz",
title="Test Z",
accesses=0,
filename="joe.txt",
collection_address="BM-2cSrapXpgDTFD8AyDmU1BGifNkB2Z6X9k8"
),
Document(
description="Test document B",
hash='gdssgsdg',
title="Test B",
accesses=3,
filename="gile.txt",
collection_address="BM-2cSrapXpgDTFD8AyDmU1BGifNkB2Z6X9k8"
),
Document(
description="Test document Bddd",
hash='afff',
title="Test B",
accesses=3,
filename="gile.txt",
collection_address="BM-2cSrapXpgDTFD8AyDmU1BGifNkB2Z6X9k8"
),
],
creation_date=datetime.datetime.now(),
oldest_date=datetime.datetime.now(),
latest_broadcast_date=datetime.datetime.now(),
latest_btc_tx="btctx1",
oldest_btc_tx="btctx12",
accesses=2,
votes=3,
votes_last_checked=datetime.datetime.now())
def obtain_movie_id(cls):
from view.menu import Menu
from controllers.controller import Controller
Controller.show_all_movies()
try:
kwargs = Menu.get_input("Choose a movie by id", movie_id=None)
movie_id = int(kwargs['movie_id'])
if cls.is_valid_id(movie_id, 'movie'):
return movie_id
else:
return None
except Exception:
print("Invalid id!\n")
def __init__(self):
#self.name = name
self.controller = Controller()
self.__user_is_active = False
self.user = False
self.commands = {
"show_movies": self.show_movies,
"show_projections": self.show_projections,
"make_reservations": self.make_reservations,
"give_up": self.give_up,
"register": self.register,
"login": self.login,
"finalize": self.finalize,
"help": self.help,
"exit": self.exit
}
def Move(self, controller, request, callback):
# service
entity_service = EntityService_Stub(channels.entity_channel)
event_service = EventService_Stub(channels.event_channel)
# model
entity = Entity()
entity.id = request.entity_id
entity = entity_service.GetEntity(controller, entity)
# event
entity_move_event = EntityMoveEvent()
# pre
event_controller = Controller()
entity_move_event.entity_id = entity.id
entity_move_event.pre_x = entity.x
entity_move_event.pre_y = entity.y
#
entity.x = request.x
entity.y = request.y
entity_service.UpdateEntity(controller, entity)
# post
entity_move_event.x = entity.x
entity_move_event.y = entity.y
# broadcast event
event_service.EntityMove(event_controller, entity_move_event)
response = MoveResponse()
return response
def Zone(self, controller, request, callback):
# service
entity_service = EntityService_Stub(channels.entity_channel)
event_service = EventService_Stub(channels.event_channel)
# model
entity = Entity()
entity.id = request.entity_id
entity = entity_service.GetEntity(controller, entity)
world = self.worlds.get(entity.world_id, None)
# event
event_controller = Controller()
entity_group_changed_event = EntityGroupChangedEvent()
# pre
entity_group_changed_event.entity_id = entity.id
entity_group_changed_event.pre_group_id = entity.group_id
#
has_changed_groups = self.handle_entity_group_membership(world, entity)
entity_service.UpdateEntity(controller, entity)
if has_changed_groups:
# post
entity_group_changed_event.group_id = entity.group_id
# broadcast event
event_service.EntityGroupChanged(event_controller, entity_group_changed_event)
response = ZoneResponse()
return response
def Teleport(self, controller, request, callback):
# service
entity_service = EntityService_Stub(channels.entity_channel)
event_service = EventService_Stub(channels.event_channel)
# model
entity = Entity()
entity.id = request.entity_id
entity = entity_service.GetEntity(controller, entity)
world = self.worlds[entity.world_id]
# event
event_controller = Controller()
entity_group_changed_event = EntityGroupChangedEvent()
# pre
entity_group_changed_event.entity_id = entity.id
entity_group_changed_event.pre_group_id = entity.group_id
#
entity.x = request.x
entity.y = request.y
self.handle_entity_group_membership(world, entity)
entity_service.UpdateEntity(controller, entity)
# post
entity_group_changed_event.group_id = entity.group_id
# broadcast event
event_service.EntityGroupChanged(event_controller, entity_group_changed_event)
response = TeleportResponse()
return response
def get_collections():
"""Get collections from the main channel"""
collection_handler = Controller()
wait_for_interrupt(exit_func,
do_import(collection_handler),
args=[collection_handler])
def validateUser(username, password):
u = User().getUserbyUsername(username)
if not u:
return False
else:
if (u.password == password):
u.setAuthenticate()
# ------------------------------------------------------------------------------
# Create New Session
newController = Controller()
newController.setUserId(u.user_id)
newController.CreateController()
sessionManager.createNewSession(u, newController)
return True
else:
return False
def __init__(self):
"""
Class needs a dummy repository and controller which are initially empty
and upon which tests can be applied.
"""
self.dummyRepo = Repository(silent=True, empty=True)
self.dummyController = Controller(self.dummyRepo)
def setUp(self):
'''Create the model, controller & GUI'''
self.current_version = '4.4.1'
self.model = Model()
self.controller = Controller(self.model)
self.controller.scanner_thread.close(
) # getting PermissionError when left open while testing - Mock it instead
self.view = View(self.model, self.controller)
def __init__(self):
#deklarasi variable
self.mapel = Mapel()
self.sekolah = Sekolah()
self.menu = Menu()
self.view = View(self)
self.controller = Controller(self)
def setUp(self):
self.controller = Controller()
self.address = self.controller.connection.create_address('Controller Test address', True)
coll_address = str(uuid.uuid1())
doc_hash_1 = str(uuid.uuid1())
doc_hash_2 = str(uuid.uuid1())
doc_hash_3 = str(uuid.uuid1())
self.test_collection = Collection(
title="Test",
description="This is a collection!",
address=self.address,
btc="123456789",
keywords=[
Keyword(name="Keyword A"),
Keyword(name="Keyword B"),
],
documents=[
Document(
description="Test document A",
hash=doc_hash_1,
title="Test A",
accesses=0,
filename="joe.txt",
collection_address="afgagahhsgh"
),
Document(
description="Test document B",
hash=doc_hash_2,
title="Test B",
accesses=3,
filename="gile.txt",
collection_address="afgagasghhhss"
),
],
creation_date=datetime.datetime.now(),
oldest_date=datetime.datetime.now(),
latest_broadcast_date=datetime.datetime.now(),
latest_btc_tx="btctx1",
oldest_btc_tx="btctx12",
accesses=2,
votes=3,
votes_last_checked=datetime.datetime.now()
)
self.test_signature = Signature(pubkey='itsakey',address=self.address)
class TestRebroadcast(unittest.TestCase):
def setUp(self):
self.controller = Controller()
self.address = self.controller.connection.create_address('Controller Test address', True)
coll_address = str(uuid.uuid1())
doc_hash_1 = str(uuid.uuid1())
doc_hash_2 = str(uuid.uuid1())
doc_hash_3 = str(uuid.uuid1())
self.test_collection = Collection(
title="Test",
description="This is a collection!",
address=self.address,
btc="123456789",
keywords=[
Keyword(name="Keyword A"),
Keyword(name="Keyword B"),
],
documents=[
Document(
description="Test document A",
hash=doc_hash_1,
title="Test A",
accesses=0,
filename="joe.txt",
collection_address="afgagahhsgh"
),
Document(
description="Test document B",
hash=doc_hash_2,
title="Test B",
accesses=3,
filename="gile.txt",
collection_address="afgagasghhhss"
),
],
creation_date=datetime.datetime.now(),
oldest_date=datetime.datetime.now(),
latest_broadcast_date=datetime.datetime.now(),
latest_btc_tx="btctx1",
oldest_btc_tx="btctx12",
accesses=2,
votes=3,
votes_last_checked=datetime.datetime.now()
)
self.test_signature = Signature(pubkey='itsakey',address=self.address)
def tearDown(self):
self.controller = None
def test_rebroadcast(self):
self.controller.cache.insert_new_collection(self.test_collection)
self.test_signature.signature = hashlib.sha256(self.test_signature.pubkey + self.test_collection.to_json()).hexdigest()
self.controller.cache.insert_new_collection(self.test_signature)
result = self.controller.rebroadcast(self.test_collection, self.address, self.address)
self.assertEqual(True, result)
def __init__(self, sys_argv):
super(App, self).__init__(sys_argv)
self.model = Model()
self.controller = Controller(self.model)
self.view = View(self.model, self.controller)
self.view.show()
# self.view.showFullScreen()
self.view.setWindowTitle("App")
class Menu:
controller = Controller()
def start(self):
name = input('Hello!\nMovie name:\n>>> ')
rating = input('\nMovie rating:\n>>> ')
self.controller.create_movie(name, rating)
self.controller.show_movies()
def PlayerJoin(self, controller, request, callback):
# service list
entity_service = EntityService_Stub(channels.entity_channel)
event_service = EventService_Stub(channels.event_channel)
# model
player = Player()
player.id = request.player_id
player = entity_service.GetPlayer(controller, player)
player.kind = 1 # Wariior
checkpoint = self.world_map.checkpoints.get(player.last_check_point, None)
world = self.get_random_world()
entity_service.UpdateEntity(controller, player)
# event list
event_controller = Controller()
entity_join_world_event = EntityJoinWorldEvent()
population_update_event = PopulationUpdateEvent()
entity_group_changed_event = EntityGroupChangedEvent()
# pre
entity_join_world_event.entity_id = player.id
entity_group_changed_event.entity_id = player.id
entity_group_changed_event.pre_group_id = player.group_id
population_update_event.world_id = world.id
population_update_event.pre_population = len(world.player_ids)
#
if not checkpoint:
random_start = randint(0, len(self.world_map.starting_areas) - 1)
checkpoint_id = self.world_map.starting_areas[random_start]
checkpoint = self.world_map.checkpoints[checkpoint_id]
player.world_id = world.id
player.x = checkpoint.x
player.y = checkpoint.y
player.hitpoints = 100
world.player_ids.append(player.id)
self.handle_entity_group_membership(world, player)
entity_service.UpdateEntity(controller, player)
# post
entity_join_world_event.world_id = player.world_id
entity_group_changed_event.group_id = player.group_id
population_update_event.population = len(world.player_ids)
# broadcast event
event_service.EntityJoinWorld(event_controller, entity_join_world_event)
event_service.PopulationUpdate(event_controller, population_update_event)
event_service.EntityGroupChanged(event_controller, entity_group_changed_event)
response = PlayerJoinResponse()
response.player_id = player.id
response.x = player.x
response.y = player.y
response.hitpoints = player.hitpoints
return response
def showConvertProcess():
plot_url = Controller.getConvertProcess()
if plot_url == Controller.false:
return Controller.false
#HTML element
model_plot = Markup(
'<img src="data:image/png;base64,{}" class="img-fluid" alt="Responsive image" width: 360px; height: 288px>'
.format(plot_url))
return model_plot
def hit_points_update(self):
browserquest_stub = BrowserQuest_Stub(channels.browserquest_channel)
entity_service = BrowserQuest_Stub(channels.entity_channel)
request = GetPlayerIDListRequest()
controller = Controller()
id_list = entity_service.GetPlayerIDList(controller, request)
for id in id_list.ids:
player = Player()
player.id = id
player = entity_service.GetPlayer(controller, player)
if player.hit_points >= 100:
continue
player.hit_points += 5
if player.hit_points >= 100:
player.hit_points = 100
health_request = HealthRequest()
health_request.hit_points = player.hit_points
controller = Controller()
controller.player_ids = [player.id]
browserquest_stub.hitpoints(controller, health_request)
def on_message(self, message):
if message is None:
return
print "data:", message
request_data = json.loads(message)
method_descriptor = self.browserquest.DESCRIPTOR.methods[request_data[0]]
request_class = self.browserquest.GetRequestClass(method_descriptor)
request = request_class()
for index in xrange(1, len(request_data)):
field_descriptor = request_class.DESCRIPTOR.fields_by_number[index]
if field_descriptor.label == 3: # repeated TODO: only WHO enter this
field = getattr(request, field_descriptor.name)
field.extend(request_data[index:])
break
else:
setattr(request, field_descriptor.name, request_data[index])
controller = Controller()
controller.connection = self.connection
controller.environ = self.environ
self.browserquest.CallMethod(method_descriptor, controller, request, None)
def hit_points_update(self):
browserquest_stub = BrowserQuest_Stub(channels.browserquest_channel)
entity_service = BrowserQuest_Stub(channels.entity_channel)
request = GetPlayerIDListRequest()
controller = Controller()
id_list = entity_service.GetPlayerIDList(controller, request)
for id in id_list.ids:
player = Player()
player.id = id
player = entity_service.GetPlayer(controller, player)
if player.hit_points >= 100:
continue
player.hit_points += 5
if player.hit_points >= 100:
player.hit_points = 100
health_request = HealthRequest()
health_request.hit_points = player.hit_points
controller = Controller()
controller.player_ids = [player.id]
browserquest_stub.hitpoints(controller, health_request)
def mob_active(self):
for mob_id in Entity.objects.mobs:
if randint(0, 1):
continue
mob = Entity.objects.entities.get(mob_id, None)
if not mob or mob.is_dead:
continue
mob_area = World.objects.mob_areas.get(mob.area_id, None)
if not mob_area:
continue
world = World.objects.worlds.get(mob_area.world_id, None)
if not world:
continue
position = World.objects.get_random_position_inside_area(mob_area)
mob.x = position['x']
mob.y = position['y']
move_request = MoveRequest()
move_request.entity_id = mob.id
move_request.entity_x = mob.x
move_request.entity_y = mob.y
controller = Controller()
controller.player_ids = World.objects.get_adjacent_player_ids(world, mob)
Service.objects.browserquest_stub.move(controller, move_request)
def start_game(self, deck=None):
if len(self.players_info) >= 2:
for user_id, user_info in enumerate(self.players_info):
nickname = user_info[0].get()
if user_info[1].get():
controller = AIController(user_id)
nickname += ' (AI)'
else:
controller = Controller(user_id)
self.game.add_player(nickname, controller)
if client_id is not None:
self.start_pooling()
self.game.tkraise()
self.game.start_game(deck)
def mob_active(self):
for mob_id in Entity.objects.mobs:
if randint(0, 1):
continue
mob = Entity.objects.entities.get(mob_id, None)
if not mob or mob.is_dead:
continue
mob_area = World.objects.mob_areas.get(mob.area_id, None)
if not mob_area:
continue
world = World.objects.worlds.get(mob_area.world_id, None)
if not world:
continue
position = World.objects.get_random_position_inside_area(mob_area)
mob.x = position['x']
mob.y = position['y']
move_request = MoveRequest()
move_request.entity_id = mob.id
move_request.entity_x = mob.x
move_request.entity_y = mob.y
controller = Controller()
controller.player_ids = World.objects.get_adjacent_player_ids(
world, mob)
Service.objects.browserquest_stub.move(controller, move_request)
class Test:
def __init__(self):
"""
Class needs a dummy repository and controller which are initially empty
and upon which tests can be applied.
"""
self.dummyRepo = Repository(silent=True, empty=True)
self.dummyController = Controller(self.dummyRepo)
def testEverything(self):
"""
Method tests most functions of classes Repository and Controller.
"""
assert self.dummyRepo.getCategory() == 'active'
assert self.dummyRepo.getTasksInCurrentCategory() == []
assert self.dummyRepo.getCurrentCategorySize() == 0
self.dummyController.addTask("test task #1")
self.dummyController.addTask("test task #2")
self.dummyController.addTask("test task #3")
self.dummyController.undo()
self.dummyController.redo()
assert self.dummyRepo.getCurrentCategorySize() == 3
self.dummyController.undo()
assert self.dummyRepo.getCurrentCategorySize() == 2
self.dummyController.undo()
assert self.dummyRepo.getCurrentCategorySize() == 1
self.dummyController.redo()
self.dummyController.redo()
assert self.dummyRepo.getCurrentCategorySize() == 3
self.dummyController.delete()
assert self.dummyRepo.getCurrentCategorySize() == 2
assert self.dummyRepo.getCurrentTask().getText() == 'test task #2'
self.dummyRepo.incrementCurrent()
assert self.dummyRepo.getCurrentTask().getText() == 'test task #3'
assert self.dummyRepo.getCurrentCategorySize() == 2
self.dummyRepo.category = 'done'
assert self.dummyRepo.getCategory() == 'done'
assert self.dummyRepo.getCurrentCategorySize() == 0
self.dummyController.addTask("done task #1")
assert self.dummyRepo.getCurrentCategorySize() == 1
self.dummyRepo.category = 'done'
self.dummyRepo.decrementCurrent()
self.dummyRepo.getCurrentTask().setStatus("active")
assert self.dummyRepo.getTaskCountFor('active') == 3
def __init__(self, iface):
loadLayersIconButton = LoadLayersIconButton(iface)
loadLayersInterface = LoadLayersInterface()
loadLayersModel = LoadLayers(iface)
self.controller = Controller(loadLayersModel, loadLayersIconButton, loadLayersInterface)
