def doAttack(self, attackQueue):
enemy = User.query(User.uid == attackQueue.attackTo).fetch()[0]
enemy.updateValues()
enemy.peopleAtAdministration = enemy.peopleAtAdministration - ((random.randint(39, 80)/100) * enemy.peopleAtAdministration)
#Stolen resources
res = { }
res["wood"] = enemy.wood - (0.05 * enemy.storageLvl) * enemy.wood
res["gold"] = enemy.gold - (0.05 * enemy.storageLvl) * enemy.gold
res["food"] = enemy.food - (0.05 * enemy.storageLvl) * enemy.food
res["stone"] = enemy.stone - (0.05 * enemy.storageLvl) * enemy.stone
#Minus the attacked city
enemy.wood -= res["wood"]
enemy.gold -= res["gold"]
enemy.food -= res["food"]
enemy.stone -= res["stone"]
queueO = Queue(queueType = Queue.TYPE_RETURN)
queueO.attackTo = attackQueue.attackTo
queueO.number = attackQueue.number
queueO.saveResources(res)
self.addQueue(queueO, 20)
queueO.put()
enemy.put()
Connection.sendMessageTo(enemy, 'attackResult', {
"text" : "You were attacked",
"lost" : res
})
Connection.sendMessageTo(self, 'attackResult', {
"text" : "Your attack was successful",
"gain" : res
})
def __init__(self, opts):
super().__init__()
# DEBUGGING
self.DEBUG = None
self._handle = lambda err: self.emit('exception', err)
on_exception = lambda err: self._log('Exception {}'.format(err))
self.on('exception', on_exception)
# self.id = opts['id'] # compatibility with five-bells-connector?
self.auth = opts['auth']
self.store = opts['store']
self.timers = dict()
self.transfer_log = Transfer_Log(opts['store'])
self.connected = False
self.connection_config = opts['auth']
self.connection = Connection(self.connection_config)
on_receive = lambda obj: self._receive(obj).catch(self._handle)
self.connection.on('receive', on_receive)
self.balance = Balance({
'store': opts['store'],
'limit': opts['auth']['limit'],
'balance': opts['auth']['balance']
})
self.balance.on('_balanceChanged', self.on_balance_change)
self.balance.on('_settlement', self.on_settlement)
self._log("Initialized Nerd Plugin Virtual: {}".format(self.auth))
def testInvalidConnectionTypeRaisesTypeError(self):
"""Test that a type error is raised when connection type is not passed in as a ConnectionType instance."""
test_connection_dict = {
'source_entity_guid': self.source_entity_guid,
'target_entity_guid': self.target_entity_guid,
'connection_type': 'FEEDS'
}
with self.assertRaises(TypeError):
Connection.FromDict(test_connection_dict)
def load_entities(self):
entities = super(ConnectionElasticsearch, self).load_entities()
connections = []
for item in entities:
connection = Connection.create_from_log(
item['_source']['message_payload'],
item['_source']['timestamp'])
if connection is not None:
connections.append(connection)
return connections
def save_connection(self):
# Get all object that need be validated
name = self.builder.get_object("txt_name")
host = self.builder.get_object("txt_host")
port = self.builder.get_object("txt_port")
user = self.builder.get_object("txt_user")
switch_key = self.builder.get_object("switch_use_key")
password = self.builder.get_object("txt_password")
file_chooser = self.builder.get_object("filechooser_key")
# Create a new Connection
if self.connection is None:
self.connection = Connection()
self.connection.name = name.get_text()
self.connection.host = host.get_text()
self.connection.port = port.get_text()
self.connection.user = user.get_text()
self.connection.use_key = switch_key.get_active()
self.connection.key_path = file_chooser.get_filename()
self.connection.password = password.get_text()
# Save the connection
saved = self.connection.save()
# Delete the Tunnels
self.connection.delete_tunnels()
# Now saved the tunnels
for tunnel in self.tunnels.get_tunnels():
# Set the ID connection
tunnel.id_connection = self.connection.id
# Save the Tunnel
tunnel.save()
# return if is saved or not
return saved
def testConnectionInitsFromDict(self):
"""Tests that a Connection instance is correctly initialized using the FromDict() class method."""
test_connection_dict = {
'source_entity_guid': self.source_entity_guid,
'target_entity_guid': self.target_entity_guid,
'connection_type': self.valid_connection_type
}
test_connection_instance = Connection.FromDict(test_connection_dict)
self.assertIsInstance(test_connection_instance, Connection)
self.assertEqual(self.valid_connection_type,
test_connection_instance.connection_type)
self.assertEqual(self.source_entity_guid,
test_connection_instance.source_entity_guid)
self.assertEqual(self.target_entity_guid,
test_connection_instance.target_entity_guid)
def load_connections(self):
# Reset the List
self.connections = []
# Create the SQL
sql = "select * from connections order by name"
# Execute the sql
results = self.dbconnection.select_query(sql)
# Create a model for every connection
for row in results:
# Create new Connection
connection = Connection()
connection.id = row['id_connection']
connection.name = row['name']
connection.host = row['host']
connection.user = row['user']
connection.port = row['port']
connection.use_key = True if row['use_key'] == 1 else False
connection.key_path = row['key_path']
# Add to the list
self.connections.append(connection)
class MessageModel():
"""class to create model message and connect to database """
def __init__(self):
self.db = Connection()
def display_message(self):
"""method to display messages """
self.db.initialize_connection()
self.db.cursor.execute("SELECT * FROM message;")
view=self.db.cursor.fetchall()
self.db.close_connection()
return view
def write_message(self,content, author):
""" """
self.db.initialize_connection()
self.db.cursor.execute("INSERT INTO message(content, publishing_date, author) VALUES (%s, now(), %s);",(content,author))
self.db.connection.commit()
self.db.close_connection()
def on_btn_edit_clicked(self, btn):
# Get the ID of selected Connection
tree = self.builder.get_object("connections_tree")
# Get the selection
(model, treeiter) = tree.get_selection().get_selected_rows()
# Get the connection ID
if model is not None and len(treeiter) > 0:
# Get the ID
connection_id = model[treeiter][1]
# Load the Connection
connection = Connection()
connection.id = connection_id
connection.load()
connection.load_tunnels()
# Open the Window with the connection
ConnectionWindow(self.refresh_connections_list, connection)
def __init__(self, opts):
self.DEBUG = None # for debugging
super().__init__()
# self.id = opts.id
# Compatibility with five bells connector; is this necessary?
self.auth = opts['auth']
self.connected = False
self.connection_config = opts['auth']
self.connection = Connection(self.connection_config)
on_receive = lambda obj: self._receive(obj).catch(self._handle)
self.connection.on('receive', on_receive)
self.connection.on('disconnect', self.disconnect)
self._expects = dict()
self._seen = dict()
self._fulfilled = dict()
self._log("Initialized Noob Plugin Virtual: {}".format(self.auth))
def delete_connection(self):
# Instance the Connection Model
connection = Connection()
connection.id = self.id_connection
# Delete the tunnels
connection.delete_tunnels()
# Delete the connection
if connection.delete() is False:
MessageBox("Fail to delete the connection, please try again")
else:
# Call the callback
self.refresh_callback()
# Close the Window
self.window.destroy()
def on_btn_connect_clicked(self, btn):
# Get the selected ID
tree = self.builder.get_object("connections_tree")
# Get the selection
(model, treeiter) = tree.get_selection().get_selected_rows()
# Get the connection ID
if model is not None and len(treeiter) > 0:
# Get the ID
connection_id = model[treeiter][1]
# Load the Model
connection = Connection()
connection.id = connection_id
connection.load()
# Get the SSH Command
command = connection.generate_ssh_command()
# Open the Shell
shell = Shell(command, connection.name)
shell.run()
def __init__(self):
self.db = Connection()
class Conference():
def __init__(self):
self.db = Connection()
def add_conference(self, titre, resume, date, heure, date_creation,
id_conferencier):
"""method adding conference"""
argument = (titre, resume, date, heure, date_creation, id_conferencier)
sql = """INSERT INTO conferences (titre, resume, date, heure, date_creation, id_conferencier) VALUES (%s,%s,%s,%s,now(),%s);"""
self.db.initialize_connection()
self.db.cursor.execute(sql, argument)
self.db.connection.commit()
self.db.close_connection()
def delete_conference(self, id):
"""method deleting conference"""
sql = """DELETE FROM conferences WHERE id=%s;"""
self.db.initialize_connection()
self.db.cursor.execute(sql, (id, ))
self.db.connection.commit()
self.db.close_connection()
def display_conference(self):
'''method selecting all conferences with the nom prenom of conferencier having the id_conferencier valable'''
SQL = " SELECT conferences.*, conferenciers.prenom, conferenciers.nom " \
" FROM conferences INNER JOIN conferenciers" \
" ON conferences.id_conferencier=conferenciers.id " \
" ORDER BY conferences.date;"
"""SELECT a.*, b.prenom, b.prenom
From conferences as a INNER JOIN conferenciers as b
ON a.id_conferencier=b.id;"""
self.db.initialize_connection()
self.db.cursor.execute(SQL)
all_conferences = self.db.cursor.fetchall()
print(all_conferences)
self.db.close_connection()
for key, value in enumerate(all_conferences):
all_conferences[key] = HydConference(value)
return all_conferences
class Nerd_Plugin_Virtual(EventEmitter):
'''
### LedgerPlugin API ###
Create a Nerd plugin
'''
def __init__(self, opts):
super().__init__()
# DEBUGGING
self.DEBUG = None
self._handle = lambda err: self.emit('exception', err)
on_exception = lambda err: self._log('Exception {}'.format(err))
self.on('exception', on_exception)
# self.id = opts['id'] # compatibility with five-bells-connector?
self.auth = opts['auth']
self.store = opts['store']
self.timers = dict()
self.transfer_log = Transfer_Log(opts['store'])
self.connected = False
self.connection_config = opts['auth']
self.connection = Connection(self.connection_config)
on_receive = lambda obj: self._receive(obj).catch(self._handle)
self.connection.on('receive', on_receive)
self.balance = Balance({
'store': opts['store'],
'limit': opts['auth']['limit'],
'balance': opts['auth']['balance']
})
self.balance.on('_balanceChanged', self.on_balance_change)
self.balance.on('_settlement', self.on_settlement)
self._log("Initialized Nerd Plugin Virtual: {}".format(self.auth))
def on_balance_change(self, balance):
self._log('balance changed to ' + balance)
self.emit('_balanceChanged')
self._send_balance()
def on_settlement(self, balance):
self._log('you should settle your balance of ' + balance)
self.emit('settlement', balance)
self._send_settle()
def get_account(self):
return self.auth['account']
def connect(self):
self.connection.connect()
def fulfill_connect(resolve, reject):
def noob_connect():
self.connected = True
self.emit('connect')
resolve(None)
self.connection.on('connect', noob_connect())
return Promise(fulfill_connect)
def disconnect(self):
def fulfill_disconnect():
self.connected = False
self.emit('disconnect')
return Promise.resolve(None)
return self.connection.disconnect().then(success=fulfill_disconnect)
def is_connected(self):
return self.connected
def get_connectors(self):
# Currently, only connections between two plugins are supported
# Thus, the list is empty
return Promise.resolve([])
def send(self, outgoing_transfer):
self._log("sending out a Transfer with tid: {}"
.format(outgoing_transfer['id']))
def send_then():
self.connection.send({
'type': 'transfer',
'transfer': outgoing_transfer
})
return self.transfer_log.store_outgoing(outgoing_transfer) \
.then(send_then()) \
.catch(self._handle)
def get_info(self):
# Using placeholder values in promise resolution
# TO-DO: What should these values be
return Promise.resolve({
'precision': '15',
'scale': '15',
'currencyCode': 'GBP',
'currencySymbol': '$'
})
def fulfill_condition(self, transfer_id, fulfillment_buffer):
fulfillment = str(fulfillment_buffer)
transfer = None
self._log('fulfilling: ' + fulfillment)
def fulfill_condition_then(stored_transfer):
transfer = stored_transfer
return self._fulfill_condition_local(transfer, fulfillment)
return self.transfer_log.get_id(transfer_id) \
.then(fulfill_condition_then) \
.catch(self._handle)
def _validate(self, fulfillment, condition):
try:
parsed_fulfillment = cc.Fulfillment.from_uri(fulfillment)
is_valid = condition == parsed_fulfillment.condition_uri
return is_valid
except Exception:
return False
def _fulfill_condition_local(self, transfer, fulfillment):
if not transfer:
raise Exception('got transfer ID for nonexistent transfer')
elif not transfer['executionCondition']:
raise Exception('got transfer ID for OTP transfer')
def _fulfill_condition_local_then(fulfilled):
if fulfilled:
raise Exception('this transfer has already been fulfilled')
else:
return Promise.resolve(None)
def _fulfill_transfer_then():
execute = transfer['executionCondition']
cancel = transfer['cancellationCondition']
# FIX DATETIME ISSUES HERE
time = str(datetime.isoformat(datetime.now()))
expires_at = str(datetime(transfer['expiresAt']))
timed_out = time > expires_at
if self._validate(fulfillment, execute) and not timed_out:
return self._execute_transfer(transfer, fulfillment)
elif cancel and self._validate(fulfillment, cancel):
return self._cancel_transfer(transfer, fulfillment)
elif timed_out:
return self._timeout_transfer(transfer)
else:
raise Exception('Invalid fulfillment')
return self.transfer_log.is_fulfilled(transfer) \
.then(_fulfill_condition_local_then) \
.then(_fulfill_transfer_then) \
.catch(self._handle)
def _execute_transfer(self, transfer, fulfillment):
fulfillment_buffer = fulfillment.encode('utf-8')
self.emit('fulfill_execution_condition', transfer, fulfillment_buffer)
# Because there is only one balance kept,
# money is not actually kept in escrow
# although it behaves as though it were
# So there is nothing to do for the execution condition
def _execute_transfer_then(type):
if type == self.transfer_log.outgoing:
return self.balance.add(transfer['amount'])
elif type == self.transfer_log.incoming:
return self.balance.sub(transfer['amount'])
else:
raise Exception("nonexistent transfer type")
return self.transfer_log.get_type(transfer) \
.then(_execute_transfer_then) \
.then(lambda _: self.transfer_log.fulfill(transfer)) \
.then(lambda _: self.connection.send({
'type': 'fulfill_execution_condition',
'transfer': transfer,
'fulfillment': fulfillment
})) \
.catch(self._handle)
def _cancel_transfer(self, transfer, fulfillment):
fulfillment_buffer = fulfillment.encode('utf-8')
self.emit('fulfill_cancellation_condition', transfer, fulfillment_buffer)
# A cancellation on an outgoing transfer means nothing
# because balances aren't affected until it executes
def _cancel_transfer_then(type):
if type == self.transfer_log.incoming:
return self.balance.add(transfer['amount'])
return self.transfer_log.get_type(transfer) \
.then(_cancel_transfer_then) \
.then(lambda _: self.transfer_log.fulfill(transfer)) \
.then(lambda _: self.connection.send({
'type': 'fulfill_cancellation_condition',
'transfer': transfer,
'fulfillment': fulfillment
}))
def _timeout_transfer(self, transfer):
self.emit('reject', transfer, 'timed out')
transaction_type = None
def _timeout_transfer_then(type):
transaction_type = type
if type == self.transfer_log.incoming:
return self.balance.add(transfer['amount'])
def _fulfill_transfer_then():
# potential problem here: figure out how to get transaction_type
# into the scope of this callback
if transaction_type == self.transfer_log.incoming:
return self.connection.send({
'type': 'reject',
'transfer': transfer,
'message': 'timed out'
})
else:
return Promise.resolve(None)
return self.transfer_log.get_type(transfer) \
.then(_timeout_transfer_then) \
.then(lambda: self.transfer_log.fulfill(transfer)) \
.then(_fulfill_transfer_then)
def get_balance(self):
return self.balance.get()
def reply_to_transfer(self, transfer_id, reply_message):
return self.transfer_log.get_id(transfer_id) \
.then(lambda stored_transfer: self.connection.send({
'type': 'reply',
'transfer': stored_transfer,
'message': reply_message
}))
def _receive(self, obj):
'''
Cases:
* obj.type == transfer
* obj.type == acknowledge
* obj.type == reject
* obj.type == reply
* obj.type == fulfillment
* obj.type == balance
* obj.type == info
'''
if obj['type'] == 'transfer':
self._log('received a Transfer with tid: ' + obj['transfer']['id'])
self.emit('receive', obj['transfer'])
return self._handle_transfer(obj['transfer'])
elif obj['type'] == 'acknowledge':
self._log('received an ACK on tid: ' + obj['transfer']['id'])
self.emit('accept', obj['transfer'], obj['message'].encode('utf-8'))
return self._handle_acknowledge(obj['transfer'])
elif obj['type'] == 'reject':
self._log('received a reject on tid: ' + obj['transfer']['id'])
self.emit('reject', obj['transfer'], obj['message'].encode('utf-8'))
return self._handle_reject(obj['transfer'])
elif obj['type'] == 'reply':
self._log('received a reply on tid: ' + obj['transfer']['id'])
def _receive_reply_then(transfer):
self.emit('reply', transfer, obj['message'].encode('utf-8'))
return Promise.resolve(None)
return self.transfer_log.get_id(obj['transfer']['id']) \
.then(_receive_reply_then)
elif obj['type'] == 'fulfillment':
self._log('received a fulfillment for tid: ' + obj['transfer']['id'])
def _receive_fulfillment_then(transfer):
self.emit('fulfillment', transfer, obj['fulfillment'].encode('utf-8'))
return self._fulfill_condition_local(transfer, obj['fulfillment'])
return self.transfer_log.get_id(obj['transfer']['id']) \
.then(_receive_fulfillment_then)
elif obj['type'] == 'balance':
self._log('received a query for the balance...')
return self._send_balance()
elif obj['type'] == 'info':
return self._send_info()
else:
self._handle(Exception('Invalid message received'))
def _handle_reject(self, transfer):
def _handle_reject_then(exists):
if exists:
print("_handle_reject_then exists")
self._complete_transfer(transfer)
else:
self.emit('_falseReject', transfer)
# used for debugging purposes
return self.transfer_log.exists(transfer) \
.then(_handle_reject_then)
def _send_balance(self):
def _send_balance_then(balance):
self._log('sending balance: ' + balance)
return self.connection.send({
'type': 'balance',
'balance': balance
})
return self.balance.get() \
.then(_send_balance_then)
def _send_settle(self):
def _send_settle_then(balance):
self._log('sending settlement notification: ' + balance)
return self.connection.send({
'type': 'settlement',
'balance': balance
})
return self.balance.get() \
.then(_send_settle_then)
def _send_info(self):
return self.get_info() \
.then(lambda info: self.connection.send({
'type': 'info',
'info': info
}))
def _handle_transfer(self, transfer):
def _handle_transfer_then(stored_transfer):
def _repeat_transfer():
raise Exception('repeat transfer id')
if stored_transfer:
self.emit('_repeateTransfer', transfer)
return self._reject_transfer(transfer, 'repeat transfer id') \
.then(_repeat_transfer)
else:
return Promise.resolve(None)
def is_valid_incoming_then(valid):
def is_valid_then(_):
self._handle_timer(transfer)
self._accept_transfer(transfer)
if valid:
return self.balance.sub(transfer['amount']) \
.then(is_valid_then)
else:
return self._reject_transfer(transfer, 'invalid transfer amount')
return self.transfer_log.get(transfer) \
.then(_handle_transfer_then) \
.then(lambda _: self.transfer_log.store_incoming(transfer)) \
.then(lambda _: self.balance.is_valid_incoming(transfer['amount'])) \
.then(is_valid_incoming_then) \
.catch(self._handle)
def _handle_acknowledge(self, transfer):
def _handle_acknowledge_then(stored_transfer):
if equals(stored_transfer, transfer):
return self.transfer_log.is_complete(transfer)
else:
self._false_acknowledge(transfer)
def is_complete_transfer_then(is_complete):
self.DEBUG = transfer
if is_complete:
self._false_acknowledge(transfer)
# don't add to balance yet if it's UTP/ATP transfer
elif not transfer['executionCondition']:
self.balance.add(transfer['amount'])
def acknowledge_transfer_then(_):
self._handle_timer(transfer)
self._complete_transfer(transfer)
return self.transfer_log.get(transfer) \
.then(_handle_acknowledge_then) \
.then(is_complete_transfer_then) \
.then(acknowledge_transfer_then)
def _false_acknowledge(self, transfer):
self.emit('_falseAcknowledge', transfer)
raise Exception("Received false acknowledge for tid: " + transfer['id'])
def _handle_timer(self, transfer):
if transfer['expiresAt']:
now = datetime.now(pytz.utc)
expiry = dateutil.parser.parse(transfer['expiresAt'])
def timer():
def timer_then(is_fulfilled):
if not is_fulfilled:
self._timeout_transfer(transfer)
self._log('automatic timeout on tid: ' + transfer['id'])
self.transfer_log.is_fulfilled(transfer) \
.then(timer_then) \
.catch(self._handle)
self.timers[transfer['id']] = Timer(5, timer)
self.timers[transfer['id']].start()
# for debugging purposes
self.emit('_timing', transfer['id'])
def _accept_transfer(self, transfer):
self._log('sending out an ACK for tid: ' + transfer['id'])
return self.connection.send({
'type': 'acknowledge',
'transfer': transfer,
'message': 'transfer accepted'
})
def _reject_transfer(self, transfer, reason):
self._log('sending out a reject for tid: ' + transfer['id'])
self._complete_transfer(transfer)
return self.connection.send({
'type': 'reject',
'transfer': transfer,
'message': reason
})
def _complete_transfer(self, transfer):
promises = list(self.transfer_log.complete(transfer))
if not transfer['executionCondition']:
promises.append(self.transfer_log.fulfill(transfer))
return Promise.all(promises)
def _log(self, msg):
log.log("{}: {}".format(self.auth['account'], msg))
class Noob_Plugin_Virtual(EventEmitter):
'''
Create a Noob plugin
@param opts
@param opts.store
@param opts.auth
@param opts.auth.account
@param opts.auth.token
@param opts.auth.host
'''
def __init__(self, opts):
self.DEBUG = None # for debugging
super().__init__()
# self.id = opts.id
# Compatibility with five bells connector; is this necessary?
self.auth = opts['auth']
self.connected = False
self.connection_config = opts['auth']
self.connection = Connection(self.connection_config)
on_receive = lambda obj: self._receive(obj).catch(self._handle)
self.connection.on('receive', on_receive)
self.connection.on('disconnect', self.disconnect)
self._expects = dict()
self._seen = dict()
self._fulfilled = dict()
self._log("Initialized Noob Plugin Virtual: {}".format(self.auth))
def _handle(self, err):
self.emit('exception', err)
raise err
def can_connect_to_ledger(self, auth):
implement()
def _log(self, msg):
log.log(self.auth['account'] + ': ' + msg)
def _expect_response(self, tid):
self._expects[tid] = True
def _expected_response(self, tid):
if tid not in self._expects:
self._expect_response(tid)
return self._expects[tid]
def _receive_response(self, tid):
self._expects[tid] = False
def _see_transfer(self, tid):
self._seen[tid] = True
def _seen_transfer(self, tid):
return tid in self._seen
def _fulfill_transfer(self, tid):
self._fulfilled[tid] = True
def _fulfilled_transfer(self, tid):
if tid not in self._fulfilled:
self._fulfilled[tid] = False
return self._fulfilled[tid]
def _receive(self, obj):
'''
Cases:
* obj.type == transfer && not seen_transfer(obj.transfer.id)
* obj.type == acknowledge && expected_response(obj.transfer.id)
* obj.type == fulfill_execution_condition &&
not fulfilled_transfer(obj.transfer.id)
* obj.type == fulfill_cancellation_condition &&
not fulfilled_trasnfer(obj.transfer.id)
* obj.type == reject && not fulfilled_transfer(obj.transfer.id)
* obj.type == reply
* obj.type == balance
* obj.type == info
* obj.type == settlement
'''
print('_receive called with obj: {}, type: {}'.format(obj, type(obj))) # debugging
if type(obj) is not dict:
self._log("unexpected non-JSON message: '{}'".format(obj))
return Promise.resolve(None)
self.DEBUG = obj # debugging
if obj['type'] == 'transfer' \
and not self._seen_transfer(obj['transfer']['id']):
self._see_transfer(obj['transfer']['id'])
self._log('received a Transfer with tid {}'
.format(obj['transfer']['id']))
self.emit("receive", obj['transfer'])
return self.connection.send({
"type": "acknowledge",
"transfer": obj['transfer'],
"message": "transfer accepted"
})
elif obj['type'] == 'acknowledge' \
and self._expected_response(obj['transfer']['id']):
self._receive_response(obj['transfer']['id'])
self._log('received an ACK on tid: {}'
.format(obj['transfer']['id']))
# TO-DO: Should accept be fulfill execution condition in OTP
self.emit("accept",
obj['transfer'],
obj['message'].encode('utf-8'))
return Promise.resolve(None)
elif obj['type'] == 'fulfill_execution_condition' \
and not self._fulfilled_transfer(obj['transfer']['id']):
self.emit("fulfill_execution_condition",
obj['transfer'],
obj['fulfillment'].encode('utf-8'))
self._fulfill_transfer(obj['transfer']['id'])
return Promise.resolve(None)
elif obj['type'] == 'fulfill_cancellation_condtion' \
and not self._fulfilled_transfer(obj['transfer']['id']):
self.emit('fullfill_cancellation_condition',
obj['transfer'],
obj['fulfillment'].encode('utf-8'))
self._fulfill_transfer(obj['transfer']['id'])
return Promise.resolve(None)
elif obj['type'] == 'reject' \
and not self._fulfilled_transfer(obj['transfer']['id']):
self._log('received a reject on tid: {}'
.format(obj['transfer']['id']))
self.emit('reject',
obj['transfer'],
obj['message'].encode('utf-8'))
return Promise.resolve(None)
elif obj['type'] == 'reply':
self._log('received a reply on tid: {}'
.format(obj['transfer']['id']))
self.emit('reply',
obj['transfer'],
obj['message'].encode('utf-8'))
return Promise.resolve(None)
elif obj['type'] == 'balance':
self._log('received balance: {}'.format(obj['balance']))
self.emit('balance', obj['balance'])
return Promise.resolve(None)
elif obj['type'] == 'info':
self.log('received info.')
self.emit('_info', obj['info'])
return Promise.resolve(None)
elif obj['type'] == 'settlement':
self._log('received settlement notification.')
self.emit('settlement', obj['balance'])
return Promise.resolve(None)
else:
raise Exception("Invalid message received")
return Promise.resolve(None)
def connect(self):
self.connection.connect()
def fulfill_connect(resolve, reject):
def noob_connect():
self.connected = True
self.emit('connect')
resolve(None)
self.connection.on('connect', noob_connect())
return Promise(fulfill_connect)
def disconnect(self):
def fulfill_disconnect():
self.connected = False
self.emit('disconnect')
return Promise.resolve(None)
return self.connection.disconnect().then(success=fulfill_disconnect)
def is_connected(self):
return self.connected
def get_connectors(self):
# Currently, only connections between two plugins are supported
# Thus, the list is empty
return Promise.resolve([])
def send(self, outgoing_transfer):
self._log("Sending out a Transfer with tid: {}"
.format(outgoing_transfer['id']))
self._expect_response(outgoing_transfer['id'])
return self.connection.send({
"type": "transfer",
"transfer": outgoing_transfer
}).catch(self._handle)
def get_balance(self):
self._log("sending balance query...")
self.connection.send({
"type": "balance"
})
def fulfill_get_balance(resolve, reject):
self.once("balance", lambda balance: resolve(balance))
return Promise(fulfill_get_balance)
def get_info(self):
self._log("sending getInfo query...")
self.connection.send({
"type": "info"
})
def fulfill_get_info(resolve, reject):
self.once("_info", lambda info: resolve(info))
return Promise(fulfill_get_info)
def get_account(self):
return self.auth['account']
def fulfill_condition(self, transfer_id, fulfillment):
return self.connection.send({
"type": "fulfillment",
"transferId": transfer_id,
"fulfillment": fulfillment
})
def reply_to_transfer(self, transfer_id, reply_message):
return self.connection.send({
"type": "reply",
"transferId": transfer_id,
"message": reply_message
})
def __init__(self):
# Create a instance of the connection class to acces the database
self.db = Connection()
def sendMessage(self, call, data):
Connection.sendMessageTo(self.user, call, data)
class View_model():
def __init__(self):
self.db = Connection()
def add_rdv(self, title, date, hour, description):
sql = """INSERT INTO calendar (title, date, hour, description) VALUES (%s, %s, %s, %s );"""
arguments = (title, date, hour, description)
self.db.initialize_connection()
self.db.cursor.execute(sql, arguments)
self.db.connection.commit()
self.db.close_connection()
def del_rdv(self, date, hour):
sql = "DELETE title, date, hour, description FROM calendar WHERE date = %s and hour = %s);"
self.db.initialize_connection()
self.db.cursor.execute(sql)
self.db.connection.commit()
self.db.close_connection()
def get_all_rdv(self, date):
sql = "SELECT * FROM calendar WHERE date = %s;"
self.db.initialize_connection()
self.db.cursor.execute(sql, (date, ))
rdv = self.db.cursor.fetchall()
self.db.close_connection()
for key, value in enumerate(rdv):
rdv[key] = Rdv(value)
return rdv
def get_rdv(self, date, hour):
sql = "SELECT * FROM calendar WHERE date = %s and hour=%s;"
self.db.initialize_connection()
self.db.cursor.execute(sql, (date, hour))
rdv = self.db.cursor.fetchone()
self.db.close_connection()
return rdv
class ConnectionWindowEvents:
window = None
builder = None
refresh_list_callback = None
tunnels = None
index_to_remove = None
connection = None
def __init__(self,
window,
builder,
refresh_list_callback,
connection=None):
# Copy the parameters
self.window = window
self.builder = builder
self.refresh_list_callback = refresh_list_callback
self.tunnels = Tunnels()
# If id_connection is not None, load the connection to Edit
if connection is not None:
self.connection = connection
self.load_connection()
# Connect the event notify::active of the switch key
switch = self.builder.get_object("switch_use_key")
switch.connect("notify::active", self.on_switch_use_key_activate)
def on_switch_use_key_activate(self, switch, active):
# Get the password fields
password = self.builder.get_object("txt_password")
confirm_password = self.builder.get_object("txt_password_confirm")
file_chooser = self.builder.get_object("filechooser_key")
if switch.get_active():
# Disable them
password.set_sensitive(False)
confirm_password.set_sensitive(False)
file_chooser.set_sensitive(True)
else:
# Enable them
password.set_sensitive(True)
confirm_password.set_sensitive(True)
file_chooser.set_sensitive(False)
def on_btn_add_clicked(self, btn):
NewTunnelWindow(self.on_added_tunnel_callback)
def on_tunnels_table_cursor_changed(self, treeview):
# Get the Index
(model, path) = treeview.get_selection().get_selected()
if model is not None and path is not None:
self.index_to_remove = model[path][3]
def on_added_tunnel_callback(self, tunnel):
# Add the tunnel on the list
self.tunnels.add_tunnel(tunnel)
# Add to the table the new model
table = self.builder.get_object("tunnels_table")
# Get and clean the model
model = table.get_model()
if model is not None:
model.clear()
# Set the new model
table.set_model(self.tunnels.get_tunnels_model())
def on_btn_remove_clicked(self, btn):
# Remove the line tunnel from the collection and rebuild the table
self.tunnels.remove_tunnel_at(self.index_to_remove)
# Rebuild the table
table = self.builder.get_object("tunnels_table")
# Get and clean the model
model = table.get_model()
if model is not None:
model.clear()
# Set the new model
table.set_model(self.tunnels.get_tunnels_model())
def on_btn_save_clicked(self, btn):
# First of all, validate the form
if self.validate_form():
# If OK, save the connection
if self.save_connection():
# Run the callback
if self.refresh_list_callback is not None:
# Call the callback to refresh the connection list
self.refresh_list_callback()
# Close the Window
self.window.destroy()
else:
# Show a message Box telling the save fails
MessageBox(
"Fail to save the connection. Check if have duplicate names. Try again"
)
def on_btn_cancel_clicked(self, btn):
self.window.destroy()
def load_connection(self):
# Get all objects
name = self.builder.get_object("txt_name")
host = self.builder.get_object("txt_host")
port = self.builder.get_object("txt_port")
user = self.builder.get_object("txt_user")
switch_key = self.builder.get_object("switch_use_key")
password = self.builder.get_object("txt_password")
confirm_password = self.builder.get_object("txt_password_confirm")
file_chooser = self.builder.get_object("filechooser_key")
table = self.builder.get_object("tunnels_table")
# Set the values
name.set_text(self.connection.name)
host.set_text(self.connection.host)
port.set_text(str(self.connection.port))
user.set_text(self.connection.user)
switch_key.set_active(self.connection.use_key)
password.set_text(self.connection.password)
confirm_password.set_text(self.connection.password)
if self.connection.key_path != 'None': # On SQLITE is saved as str 'None'
file_chooser.set_filename(self.connection.key_path)
# Check if use key is checked, and call the function to switch the fields
if self.connection.use_key:
self.on_switch_use_key_activate(switch_key,
self.connection.use_key)
# Also, load the tunnels
self.tunnels = self.connection.get_tunnels()
# Get and clean the model
model = table.get_model()
if model is not None:
model.clear()
# Set the new model
table.set_model(self.tunnels.get_tunnels_model())
def validate_form(self):
# Get all object that need be validated
name = self.builder.get_object("txt_name")
host = self.builder.get_object("txt_host")
port = self.builder.get_object("txt_port")
user = self.builder.get_object("txt_user")
switch_key = self.builder.get_object("switch_use_key")
password = self.builder.get_object("txt_password")
confirm_password = self.builder.get_object("txt_password_confirm")
file_chooser = self.builder.get_object("filechooser_key")
# Check for the name
if len(name.get_text()) == 0:
MessageBox("Name can't be empty!")
return False
# Check for the host
if len(host.get_text()) == 0:
MessageBox("Host can't be empty!")
return False
# Check for the port
port_number = port.get_text()
if len(port_number) == 0:
MessageBox("Port can't be empty!")
return False
elif not port_number.isdigit() or int(port_number) <= 0 or int(
port_number) > 65565:
MessageBox("Port must be between 1 and 65565")
return False
# Check for the user
if len(user.get_text()) == 0:
MessageBox("User can't be empty!")
return False
# If switch key is On, the filechooser must have a file
if switch_key.get_active():
# If file chooser haven't any file, return error
if file_chooser.get_filename() is None:
MessageBox("You must select a key file")
return False
else:
# Check if password is empty
if len(password.get_text()) == 0:
MessageBox("Password can't be empty!")
return False
# Check if the password are the same, if not, return error
if password.get_text() != confirm_password.get_text():
MessageBox("The passwords not match")
return False
# If all pass, return True
return True
def save_connection(self):
# Get all object that need be validated
name = self.builder.get_object("txt_name")
host = self.builder.get_object("txt_host")
port = self.builder.get_object("txt_port")
user = self.builder.get_object("txt_user")
switch_key = self.builder.get_object("switch_use_key")
password = self.builder.get_object("txt_password")
file_chooser = self.builder.get_object("filechooser_key")
# Create a new Connection
if self.connection is None:
self.connection = Connection()
self.connection.name = name.get_text()
self.connection.host = host.get_text()
self.connection.port = port.get_text()
self.connection.user = user.get_text()
self.connection.use_key = switch_key.get_active()
self.connection.key_path = file_chooser.get_filename()
self.connection.password = password.get_text()
# Save the connection
saved = self.connection.save()
# Delete the Tunnels
self.connection.delete_tunnels()
# Now saved the tunnels
for tunnel in self.tunnels.get_tunnels():
# Set the ID connection
tunnel.id_connection = self.connection.id
# Save the Tunnel
tunnel.save()
# return if is saved or not
return saved
def main():
"""Program file for product substitution program, by 'Pur Beurre'."""
try:
parser = argparse.ArgumentParser(description="Launch the program !")
parser.add_argument("-v",
"--verbose",
action="store_true",
help="add output verbosity")
parser.add_argument("--install_database",
action="store_true",
help="install database")
args = parser.parse_args()
verbose = args.verbose
if args.verbose:
print("Running '{}'".format(__file__))
if args.install_database:
# Ask informations for sql server connection
# and save them in 'conn_params.json'.
Run = Ui()
host, user, password = Run.connection_params()
Json().save_connection_params(host, user, password)
print("Installing...")
# Server sql connection.
Log = Connection(host, user, password)
# Read sql.
Sql = SqlRead(verbose)
sql_readed = Sql.read_sql(SQL_FILE)
# Write database name in 'database_name.json'.
Sql.database_name(sql_readed)
# Create database.
Create(Log, sql_readed).create_db(verbose)
# Retrieves the maximum number of characters for the fields.
Fields_charmax = Fetch(Log).characters_max()
# Retrives datas from Api and reject unsuitable datas.
Api_data = ApiRequests().api_get_data(Fields_charmax, verbose)
# Insertion in database.
Insert(Log, verbose).insert_data(Api_data)
print("Database installed.")
else:
try:
with open("model/conn_params.json"):
pass
with open("model/database_name.json"):
pass
except IOError:
print(
"\nInformations de connection manquantes.\n",
"Veuillez utiliser l'option : --install_database\n",
)
exit()
# Load connection parameters from json.
host, user, password = Json().read_connection_params()
# Server connection.
Log = Connection(host, user, password)
# Database connection.
Log_db = Log.database_log()
# Booleans for loops.
Loop = False
log_choice = False
# User account.
user_name = False
Run = Ui()
while log_choice is False:
log_choice = Run.log_menu()
# User log.
if log_choice == 1:
logged = False
while logged is False:
user_name = Run.log_user()
if isinstance(user_name, str):
try:
request_lists = RequestsLists().user_id(user_name)
user_id = Orm(Log_db).simple_request(
request_lists)[0]
logged = True
except IndexError:
print("\n- Ce nom d'utilisateur n'existe pas.")
else:
print("\n- Veuillez saisir un nom d'utilisateur.")
# User create account.
elif log_choice == 2:
while user_name is False:
user_name = Run.create_user()
try:
request_lists = RequestsLists().user_id(user_name)
user = Orm(Log_db).simple_request(request_lists)
user_name = False
print("\nCe nom d'utilisateur existe déjà.")
except IndexError:
insert_lists = RequestsLists().user_insert(user_name)
Insert(Log_db, verbose).insert_user(insert_lists)
request_lists = RequestsLists().user_id(user_name)
user_id = Orm(Log_db).simple_request(request_lists)[0]
while Loop is False:
# Booleans for loops.
menu_choice = False
category = False
product_id = False
substitute_id = False
save_choice = False
# Display menu.
while menu_choice is False:
menu_choice = Run.menu()
# Launch search for substitute.
if menu_choice == 1:
# Display categories
while category is False:
category = Run.categories()
# Display products.
while product_id is False:
product_id = Run.products(Log, category)
# Display substitute
while substitute_id is False:
substitute_id = Run.substitute(Log, product_id,
category)
# Save result, leave or loop.
while save_choice is False:
save_choice = Run.save_menu(Log)
if save_choice == 1:
insert_lists = RequestsLists().save_search(
product_id, substitute_id, user_id)
Insert(Log_db, verbose).insert_save(insert_lists)
print("\nRecherche sauvegardée.")
elif save_choice == 2:
pass
elif save_choice == 3:
exit(Ui().bye_message(user_name))
# Display saved searches.
elif menu_choice == 2:
Run.saves_display(Log_db, user_id)
# Quit.
elif menu_choice == 3:
exit(Ui().bye_message(user_name))
except KeyboardInterrupt:
Ui().bye_message(user_name)
class Conferencier():
def __init__(self):
self.db = Connection()
def add_conferencier(self, prenom, nom, description, profession):
"""method adding conferencier"""
argument=(prenom, nom, description, profession)
sql="""INSERT INTO conferenciers (prenom, nom, description, profession) VALUES (%s,%s,%s,%s);"""
self.db.initialize_connection()
self.db.cursor.execute(sql, argument)
self.db.connection.commit()
self.db.close_connection()
def delete_conferencier(self, id):
"""method deleting conferencier"""
sql="""DELETE FROM conferenciers WHERE id=%s;"""
self.db.initialize_connection()
self.db.cursor.execute(sql, (id,))
self.db.connection.commit()
self.db.close_connection()
def display_conferencier(self):
'''method selecting all conferenciers that have actif status'''
self.db.initialize_connection()
self.db.cursor.execute("SELECT * FROM conferenciers WHERE statut_actif=True ;")
actif_conferenciers = self.db.cursor.fetchall()
for key, value in enumerate(actif_conferenciers):
actif_conferenciers[key]=HydConferencier(value)
self.db.close_connection()
return actif_conferenciers
def connect(self, fromVar, toVar):
"""
Connect fromVar to toVar, add all modules of
toVar-module-instrument to instrument of fromVar-module and
sort modules list in the correct order for csound code
generation.
@type fromVar: model.var.OutVar
@param fromVar: Startpoint of connection.
@type toVar: model.var.InVar
@param toVar: Endpoint of connection.
@raise ConnectionError: If connection from module to itself.
@rtype : model.Connection.connection
@return: New connection.
"""
if fromVar.module == toVar.module:
raise ConnectionError, "Can\'t connect module with itself"
if fromVar.type == "a" and toVar.type == "i":
raise ConnectionError, \
"Can\'t connect audio rate output to initialisation rate input"
if fromVar.type == "i" and toVar.type == "a":
raise ConnectionError, \
"Can\'t connect initialisation rate output to audio rate input"
if toVar.connection:
raise ConnectionError, "There's already a connection to this input "
newConnection = Connection(fromVar, toVar)
targetInstr = fromVar.module.instrument
leftInstr = toVar.module.instrument
targetInstr.connections.append(newConnection)
toVar.connection = newConnection
# Append all modules and connections of leftInstr to
# targetInstr and remove leftInstr from workspace
if targetInstr != leftInstr:
for m in leftInstr.modules:
m.instrument = targetInstr
targetInstr.modules.append(m)
for c in leftInstr.connections:
targetInstr.connections.append(c)
self.instruments.remove(leftInstr)
else:
if targetInstr.modules.index(fromVar.module) \
> targetInstr.modules.index(toVar.module):
# Place toVar module behind fromVar module and close
# the gap
fromIdx = targetInstr.modules.index(fromVar.module)
toIdx = targetInstr.modules.index(toVar.module)
targetInstr.modules \
= targetInstr.modules[:toIdx] \
+ targetInstr.modules[(toIdx+1):fromIdx] \
+ [targetInstr.modules[fromIdx], \
targetInstr.modules[toIdx]] \
+ targetInstr.modules[(fromIdx+1):]
self.setChanged()
arg = ['connect', newConnection]
self.notifyObservers(arg)
return newConnection
class EventModel():
"""Class to perform all queries related to the event table in the database"""
def __init__(self):
# Create a instance of the connection class to acces the database
self.db = Connection()
def show_events(self, date):
"""method to display all the events of the day """
sql = "SELECT * FROM events WHERE date = %s;"
self.db.initialize_connection()
self.db.cursor.execute(sql, (date, ))
events = self.db.cursor.fetchall()
self.db.close_connection()
for key, value in enumerate(events):
events[key] = Event(value)
return events
def display_one_event(self, date, time):
"""method to dislay one event """
sql = "SELECT * FROM events WHERE date = %s AND time = %s;"
self.db.initialize_connection()
self.db.cursor.execute(sql, (date, time))
event = self.db.cursor.fetchone()
self.db.close_connection()
if event:
return Event(event)
return False
def add_event(self, event):
""" """
sql = "INSERT INTO events(title, date, time, description) VALUES(%s, %s, %s, %s);"
percent_s = (event.title, event.date, event.time, event.description)
self.db.initialize_connection()
self.db.cursor.execute(sql, percent_s)
self.db.connection.commit()
self.db.close_connection()
def delete_event(self, date, time):
""" """
sql = "DELETE FROM events WHERE date = %s AND time = %s;"
percent_s = (date, time)
self.db.initialize_connection()
self.db.cursor.execute(sql, percent_s)
self.db.connection.commit()
self.db.close_connection()
def update_event(self, title, date, time, description, actual_date,
actual_time):
""" """
sql = "UPDATE events SET title=%s, date=%s, time=%s, description = %s WHERE date = %s AND time = %s;"
percent_s = (event.title, event.date, event.time, event.description,
actual_date, actual_time)
self.db.initialize_connection()
self.db.cursor.execute(sql, percent_s)
self.db.connection.commit()
self.db.close_connection()
