class Vote(Database().DynamicDocument):
''' class to store vote data '''
number = Database().IntField()
symbol = Database().StringField(max_length=5)
ticker = Database().StringField(max_length=40)
created_at = Database().DateTimeField(default=datetime.now())
def test_end_appointment(client):
db.inicialize()
lastId = db.getLast()
physician_id = "ea959b03-5577-45c9-b9f7-a45d3e77ce82"
patient_id = "86158d46-ce33-4e3d-9822-462bbff5782e"
request_payload = {"id": str(lastId[0]["_id"])}
response = client.post("/end", json=request_payload)
result = response.get_json()
assert response.status_code == 200
assert result is not None
assert "payload" in result
assert "id" in result['payload']
assert result['payload']['id'] == request_payload['id']
assert "physician_id" in result['payload']
assert result['payload']['physician_id'] == physician_id
assert "patient_id" in result['payload']
assert result['payload']['patient_id'] == patient_id
assert "end_date" in result['payload']
assert validate_datetime(result['payload']['end_date'])
assert "price" in result['payload']
def main():
parser = argparse.ArgumentParser()
parser.add_argument("-c",
"--clear_db",
action="store_true",
help="Clear database")
parser.add_argument("-d",
"--daemon",
action="store_true",
help="Run as daemon")
parser.add_argument("-g",
"--initialize_geolocation",
action="store_true",
help="(Re-)Initialize geolocation module")
parser.add_argument(
"-u",
"--initialize_unsafe",
action="store_true",
help="Initialize a new set of unsafe URLs, domains and IPs")
args = parser.parse_args()
if args.clear_db:
config = json.load(open("config.json"))
db = Database(config["database"]["user"],
config["database"]["password"],
config["database"]["host"], config["database"]["port"],
config["database"]["db"])
db.clear_db()
if args.initialize_unsafe:
initialize_unsafe_connections_list()
if args.initialize_geolocation:
GeoLocation.initialize()
if args.daemon:
Scheduler.run()
def get_password():
try:
database = Database(config)
except TypeError:
return jsonify({"message": "Нет подключения к БД"})
result = {}
if not request.get_json(silent=True):
return jsonify({"message": "JSON не найден"}), 400
number_phone = request.get_json(silent=True).get("number_phone")
if not number_phone:
return jsonify({"error": "Телефон не найден"}), 404
isFind = database.select_data(
sql.SQL("SELECT id FROM users WHERE number_phone={number_phone}").
format(number_phone=sql.Literal(number_phone)))
if not isFind:
isFind = create_user(database, number_phone)
if isFind:
password = generate_password()
update_password(database, isFind[0],
generate_password_hash(password, method='sha256'))
send_password(password, number_phone)
update_connection_log(database, isFind[0], request.remote_addr)
database.close()
return "Ok"
def auth_api():
try:
database = Database(config)
except TypeError:
return jsonify({"message": "Нет подключения к БД"})
number_phone = request.get_json(silent=True).get("number_phone")
password = request.get_json(silent=True).get("password")
user_data = database.login({"number_phone": number_phone})
if user_data:
if time() - user_data[4].timestamp() >= 300:
update_password(database, user_data[0], "")
return jsonify({'message': 'Время пароля истекло'}), 401, {
'ContentType': 'application/json'
}
if check_password_hash(user_data[1], password):
if user_data[3] == True:
user = User(id=user_data[0],
number_phone=number_phone,
role=user_data[2])
authorize[user.get_token()] = user
update_password(database, user_data[0], "")
return jsonify({
"UserToken": user.get_token(),
"role": user.get_role()
})
return jsonify({'message': 'Пользователь заблокирован'}), 401, {
'ContentType': 'application/json'
}
return jsonify({'message': 'Неправильный логин или пароль'}), 401, {
'ContentType': 'application/json'
}
def get_order():
low_stock = []
#Get data needed for order
results = Database.join(
"Products.order_qty, Products.id, Stock.stock_healthy, Stock.site_id, Stock.id",
"Stock", "Products", "product_id", "id")
for result in results:
if result[2] == 0:
address = Database.find("Sites", "name", result[3])[0][1]
low_stock.append([result[0], result[1], address])
#Set the all the stock that was low to ordered
Database.update("Stock", "stock_healthy", "NULL", "stock_healthy",
0)
order = ""
#Setup email without list formatting
for stock in low_stock:
line = ""
for info in stock:
line = line + " " + str(info)
order = order + "\n" + line
make_order(order)
def test_add_user_blank_first_name(self, setup_db,
test_input_bad_first_name,
test_input_good_first_name,
test_input_last_name, test_input_email,
test_input_password, expected):
test_db = Database(setup_db)
user = UserController(test_db)
set_keyboard_input([
test_input_bad_first_name, test_input_good_first_name,
test_input_last_name, test_input_email, test_input_password,
test_input_password
])
user.addNewUser()
output = get_display_output()
assert output == [
"Enter new user information, all information is case-sensitive.",
"First Name: ",
"First name can not be blank. Please enter a first name.",
"First Name: ", "Last Name: ", "E-Mail Address: ", "Password: "******"Re-Enter Password: "******"\n New User was successfully added"
]
result = test_db.query_user_db(
"SELECT EXISTS(SELECT * FROM Employee WHERE FirstName is '%s' AND LastName is "
"'%s' AND Email is '%s' AND Password is '%s')" %
(test_input_good_first_name, test_input_last_name,
test_input_email, test_input_password))
assert result[0] == expected
def insert_test_data():
pin = 0
for _, (city, _, _, _) in counties.items():
for i in range(5):
surname = "{}{}".format(surnames[i % 2], i)
name = "{}{}".format(names[i % 2], i)
date_b = now
while True:
try:
date_b = date_b.replace(month=months_b[i])
break
except:
date_b = date_b.replace(day=date_b.day - 1)
date_d = now
while True:
try:
date_d = date_d.replace(month=months_d[i])
break
except:
date_d = date_d.replace(day=date_d.day - 1)
try:
Database.insert_birth(pin, surname, name, date_b, city)
Database.insert_death(pin, date_d, city)
except Exception as e:
print(e)
continue
finally:
pin += 1
def insert_test_counties():
for county, (city, lat, longi, rad) in counties.items():
try:
Database.insert_county(county, lat, longi, rad)
Database.insert_city(city, lat, longi, rad / 10, county)
except Exception as e:
print(e)
continue
def callback(ch, method, properties, body):
print(" [x] Received %s" % body)
payload = json.loads(body.decode())
print(" [x] Saving financial entry in the database")
db.inicialize()
db.save(payload)
print(" [x] Done")
ch.basic_ack(delivery_tag=method.delivery_tag)
def main_prize_action(self, params=None):
database = Database()
try:
response = database.get_next_lottery_main_prize()
self.send_request(response['response'])
except:
self.send_request('UNEXPECTED_ERROR')
del database
def get_balance_action(self, params=None):
database = Database()
if self.userID:
response = database.get_balance(self.userID)
self.send_request(response['response'])
else:
self.send_request('NO_LOGIN')
del database
def won_list_action(self, params=None):
database = Database()
try:
response = database.get_won_list()
self.send_request(response['response'])
except:
self.send_request('UNEXPECTED_ERROR')
del database
class BaseTestCase(TestCase):
def setUp(self):
self.db = Database('sqlite://', echo=False) # in memory database
self.db.create()
self.ck = CryptoKey()
self.hosts = Hosts(self.db, self.ck)
def tearDown(self):
self.db.drop()
def __init__(self):
self.username = None
self.password = None
self.session = None
self.language = None
self.vocab = []
self.wordHash = {}
self.flagHash = {}
self.db = Database()
def handle_disconnection():
# handles disconnection from the server
print("DISCONNECT")
db = Database()
msg = {"name": session[NAME_KEY], "message": " has left the chat"}
db.insert_message(session[NAME_KEY], " has left the chat")
result = db.get_messages_by_name(1, session[NAME_KEY])
result = trim_seconds_from_message(result)
socketio.emit("message response", result)
def handle_event(json, methods=["GET", "POST"]):
if len(json["name"]) >= 2:
db = Database()
db.insert_message(json["name"], json["message"])
result = db.get_messages_by_name(
1, json["name"]
) # getting the last message from the database( the one that was just inserted above)
result = trim_seconds_from_message(result)
socketio.emit("message response",
result) # sending it back to the clients
def last_won_action(self, params=None):
database = Database()
try:
if params and len(params) == 1:
response = database.get_last_lotto(int(params[0]))
self.send_request(response['response'])
else:
self.send_request('PARAMS_COUNT')
except:
self.send_request('UNEXPECTED_ERROR')
del database
def my_coupons_action(self, params=None):
database = Database()
try:
userID = self.userID
if self.userID:
response = database.get_user_coupons_list_with_lottery(userID)
self.send_request(response['response'])
else:
self.send_request('NO_LOGIN')
except:
self.send_request('UNEXPECTED_ERROR')
del database
class Action(Database().DynamicDocument):
''' class to hold the different possible actions of a pitch '''
name = Database().StringField(max_length=500)
vote_count = Database().IntField(default=0)
vote_numbers = Database().ListField()
vote_symbol = Database().StringField(max_length=10)
ticker = Database().StringField(max_length=50)
action = Database().StringField(max_length=50)
amount = Database().IntField()
action_id = Database().IntField()
created_at = Database().DateTimeField(default=datetime.now())
def start_appointment(start_date, physician_id, patient_id):
db.inicialize()
payload = {
"start_date": start_date,
"physician_id": physician_id,
"patient_id": patient_id
}
item_id = db.insert(dict(payload))
payload["id"] = item_id
return payload
def setUp(self):
self.client = app.test_client(self)
# RUN 'set APP_SETTINGS=testing' to set testing environment (for database)
self.database_obj = Database(app)
# get Authorization token (used for all protected endpoints)
signup_response = self.client.post('/api/v1/auth/signup',
data=json.dumps(
TestData.user_data2),
content_type='application/json')
token_json_dict = json.loads(signup_response.data.decode())
self.access_token = token_json_dict['access_token']
def add_balance_action(self, params=None):
database = Database()
try:
if params and len(params) == 1:
userID = self.userID
if self.userID:
response = database.add_balance(userID, float(params[0]))
self.send_request(response['response'])
else:
self.send_request('NO_LOGIN')
except:
self.send_request('UNEXPECTED_ERROR')
del database
def register_action(self, params=None):
database = Database()
try:
if params and len(params) == 4:
response = database.register(
params[0], params[1], params[2],
hashlib.md5(params[3].encode()).digest())
self.send_request(response['response'])
else:
self.send_request('PARAMS_COUNT')
except:
self.send_request('UNEXPECTED_ERROR')
del database
def test_insert_user_db(self, setup_db, employee_id, first_name, last_name,
email, password):
db = Database(setup_db)
insert_statement = "INSERT INTO Employee (EmployeeID, FirstName, LastName, Email, Password) " + \
"VALUES (" + str(employee_id) + ",'" + first_name + "','" + last_name + "','" + email + \
"','" + password + "')"
query_statement = "SELECT EXISTS(SELECT * FROM Employee WHERE EmployeeID is " + str(employee_id) + \
" AND FirstName is '" + first_name + "' AND LastName is '" + last_name + \
"' AND Email is '" + email + "' AND Password is '" + password + "')"
insert_results = db.insert_user_db(insert_statement)
query_results = db.query_user_db(query_statement)
assert insert_results == True
assert query_results[0] == 1
def main(self):
if not database_exists(self.CONFIG["database_url"]):
self.logger.info("Creating new database")
Database.init_db(self.CONFIG["database_url"])
self.logger.info("Connecting to the database")
db = Database.from_url(self.CONFIG["database_url"])
users = self.update_users_preferences(db)
venues = db.get_distinctive_items("venue")
artists = db.get_distinctive_items("artist")
promoters = db.get_distinctive_items("promoter")
# go through venues
new_events = []
for venue in venues:
self.logger.info(f"Checking {venue['name']} venue...")
venue["type"] = "venue"
venue_events = self.get_events(
venue, self.CONFIG["venue_url_prefix"] + venue["tag"]
)
new_venue_events = self.add_to_database(db, venue_events)
new_events.extend(new_venue_events)
for artist in artists:
self.logger.info(f"Checking {artist['name']} artist...")
artist["type"] = "artist"
artist_events = self.get_events(
artist, self.CONFIG["artist_url_prefix"] + artist["tag"]
)
new_artist_events = self.add_to_database(db, artist_events)
new_events.extend(new_artist_events)
for promoter in promoters:
self.logger.info(f"Checking {promoter['name']} promoter...")
promoter["type"] = "promoter"
promoter_events = self.get_events(
promoter, self.CONFIG["promoter_url_prefix"] + promoter["tag"]
)
new_promoter_events = self.add_to_database(db, promoter_events)
new_events.extend(new_promoter_events)
db.commit()
for new_event in new_events:
self.add_event_notifications(new_event, users)
self.send_emails(users)
def end_appointment(item_id):
db.inicialize()
item = db.get(item_id)
start_date = datetime.strptime(item["start_date"], '%Y-%m-%d %H:%M:%S')
end_date = datetime.now()
timedelta = end_date - start_date
hours = (timedelta.seconds % 3600) + 1
price = hours * PRICE_BY_HOUR
item["end_date"] = end_date.strftime("%Y-%m-%d %H:%M:%S")
item["price"] = price
if (db.save(item)):
payload = {
"id": item_id,
"start_date": item["start_date"],
"physician_id": item["physician_id"],
"patient_id": item["patient_id"],
"end_date": item["end_date"],
"price": item["price"],
}
financial_payload = json.dumps({
"appointment_id": item_id, # id da consulta
"total_price": item["price"],
})
# register a RabbitMQ message
credentials = pika.PlainCredentials('guest', 'guest')
parameters = pika.ConnectionParameters('rabbit', 5672, '/',
credentials)
connection = pika.BlockingConnection(parameters)
channel = connection.channel()
channel.queue_declare(queue='financial_queue', durable=True)
channel.basic_publish(
exchange='',
routing_key='financial_queue',
body=financial_payload,
properties=pika.BasicProperties(
delivery_mode=2, # make message persistent
))
connection.close()
return payload
else:
return False
def ingest_latest_obs(self):
with Database(DATABASE_PATH) as db:
file_content = self.api.get_latest_obs()
if file_content:
df = file_content_to_dataframe(file_content)
obs_list = []
timestamp = int(df.ta.index[0][1].timestamp())
if (latest_timestamp := db.get_latest_timestamp()
) and latest_timestamp == timestamp:
print(
f'timestep already in database: {datetime.fromtimestamp(timestamp).isoformat()}'
)
return
for row in df.itertuples():
station_id = int(row.Index[0])
station = Station(
id=station_id,
name=row.stationname,
latitude=row.lat,
longitude=row.lon,
height=row.height,
)
db.add_station(station)
obs = Observation(
timestamp=int(row.Index[1].timestamp()),
station_id=station_id,
)
for element_name, mapping in mappings.items():
setattr(obs, element_name,
getattr(row, mapping.knmi_alias, None))
obs_list.append(obs)
db.add_observations(obs_list)
def instant_order(stock_id):
#Get dat needed for order
product_id = Database.find("Stock", "id", stock_id)[0][1]
site_id = Database.find("Stock", "id", stock_id)[0][2]
order_qty = Database.find("Products", "id", product_id)[0][2]
address = Database.find("Sites", "name", site_id)[0][1]
details = product_id, order_qty, address
order = ""
#Setup email without list formatting
for detail in details:
order = order + str(detail) + " "
make_order(order)
def create_app(*config_cls) -> Flask:
# preprocess.preprocess_deepec()
# preprocess.preprocess_ecpred()
# preprocess.preprocess_ecami()
# preprocess.preprocess_detect_v2()
if len(config_cls) == 0:
config_cls = (ProductionLevelConfig, RemoteConfig)
config_cls = [
config() if isinstance(config, type) else config
for config in config_cls
]
log(
message="Flask application initialized with {}".format(", ".join(
[config.__class__.__name__ for config in config_cls])),
keyword="INFO",
)
flask_app = Flask(__name__)
for config in config_cls:
flask_app.config.from_object(config)
register_extensions(flask_app)
register_views(flask_app)
register_hooks(flask_app)
with flask_app.app_context():
c = flask_app.config
Database(c['DB_HOST'], c['DB_USER'], c['DB_PASSWORD'],
c['DB_DATABASE'])
return flask_app
def test_hosts(self):
db = Database(C.getConnectionString())
db.recreate()
hosts = Hosts(db)
h1 = hosts.create(u"test1", u"192.168.6.66")
h2 = hosts.create(u"test2", u"192.168.6.77", u"ąść", u"password")
allHosts = hosts.getAllHostsNames()
self.assertListEqual([u"test1", u"test2"], allHosts)
h2.user = u"łęść"
# get once again host from database and asert its modified
h2bis = hosts.get(u"test2")
self.assertEqual(u"łęść", h2bis.user)
# fields required
self.assertRaises(IntegrityError, hosts.create,
None, None, None, None)
def reddit_bot_loop():
logging.info("Starting reddit bot loop")
bot = RedditBot()
db = Database()
while db.any_update_in_progress():
# If any metadata updates are happening, wait for them to finish.
logging.info("Waiting for updates to finish...")
time.sleep(10)
for comment in bot.fetch_comments(SUBREDDIT, key=lambda cmt: not db.replied_to_comment(cmt.id) and should_respond(cmt.created, cmt.body, cmt.author)):
logging.info("Responding to comment: " + str(comment))
for requested_date in setlist.get_setlist_dates(comment.body):
reply_text = setlist.get_setlist(requested_date)
try:
comment.reply(reply_text)
db.record_comment_reply(comment, requested_date)
except exceptions.APIException as e:
# Probably a RateLimit
logging.info("caught an exception: " + str(e))
logging.info("sleeping..")
time.sleep(5)
for submission in bot.fetch_submissions(SUBREDDIT, key=lambda sub: not db.replied_to_comment(sub.id) and should_respond(sub.created, sub.selftext, sub.author)):
logging.info("Responding to submission: " + str(submission))
for requested_date in setlist.get_setlist_dates(submission.selftext):
reply_text = setlist.get_setlist(requested_date)
try:
submission.reply(reply_text)
db.record_submission_reply(submission, requested_date)
except exceptions.APIException as e:
# Probably a RateLimit
logging.info("caught an exception: " + str(e))
logging.info("sleeping..")
time.sleep(5)
logging.info("Complete.")
db.connection.close()
def setUp(self):
self.db = Database('sqlite://', echo=False) # in memory database
self.db.create()
self.ck = CryptoKey()
self.hosts = Hosts(self.db, self.ck)
def __init__(self):
super(MainWindow, self).__init__()
self.config = Config()
self.db = Database(self.config.getConnectionString())
cryptoKey = self.getCryptoKey()
self.hosts = Hosts(self.db, cryptoKey)
# menu used for each host
self.hostMenu = QMenu()
self.editAction = QAction(QIcon(':/ico/edit.svg'), "Edit", self.hostMenu)
self.editAction.triggered.connect(self.editHost)
self.hostMenu.addAction(self.editAction)
# menu used for headers of groups
self.groupsHeaderMenu = QMenu()
self.editGroupAction = QAction(QIcon(':/ico/edit.svg'), "Edit group", self.groupsHeaderMenu)
self.editGroupAction.triggered.connect(self.editGroup)
self.deleteGroupAction = QAction(QIcon(':/ico/remove.svg'), "Delete group", self.groupsHeaderMenu)
self.deleteGroupAction.triggered.connect(self.deleteGroup)
self.groupsHeaderMenu.addAction(self.editGroupAction)
self.groupsHeaderMenu.addAction(self.deleteGroupAction)
self.duplicateAction = QAction(QIcon(':/ico/copy.svg'), "Duplicate", self.hostMenu)
self.duplicateAction.triggered.connect(self.duplicateHost)
self.hostMenu.addAction(self.duplicateAction)
# todo: confirm for delete action
self.deleteAction = QAction(QIcon(':/ico/remove.svg'), "Delete", self.hostMenu)
self.deleteAction.triggered.connect(self.deleteHost)
self.hostMenu.addAction(self.deleteAction)
self.connectFramelessMenu = actions.generateScreenChoseMenu(self.hostMenu, self.connectFrameless,
':/ico/frameless.svg', "Connect frameless")
self.hostMenu.addMenu(self.connectFramelessMenu)
self.assignGroupAction = QAction("Assign group", self.hostMenu)
self.assignGroupAction.triggered.connect(self.assignGroup)
self.hostMenu.addAction(self.assignGroupAction)
# setup main window
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# when top level changed, we changing dock title bar
self.dockWidgetTileBar = DockWidgetTitleBar()
self.ui.hostsDock.setTitleBarWidget(self.dockWidgetTileBar)
self.ui.hostsDock.topLevelChanged.connect(self.dockLevelChanged)
# set global menu
self.globalMenu = QMenu()
self.globalMenu.addAction(QIcon(':/ico/add.svg'), 'Add host', self.addHost)
# groups menu
self.groupsMenu = QMenu("Groups")
self.groupsMenu.aboutToShow.connect(self.setGroupsMenu)
self.globalMenu.addMenu(self.groupsMenu)
# disable menu indicator
self.ui.menu.setStyleSheet("QPushButton::menu-indicator {image: none;}")
self.positionMenu = QMenu("Dock position")
self.positionMenu.addAction("Left", lambda: self.setDockPosition(Qt.LeftDockWidgetArea))
self.positionMenu.addAction("Right", lambda: self.setDockPosition(Qt.RightDockWidgetArea))
self.positionMenu.addAction("Float", self.setDockFloat)
self.globalMenu.addMenu(self.positionMenu)
self.globalMenu.addAction('Change tray icon visibility', self.changeTrayIconVisibility)
self.globalMenu.addAction('Settings', self.showSettings)
self.globalMenu.addAction('Quit', self.close)
self.ui.menu.setMenu(self.globalMenu)
# set events on hosts list
self.ui.hostsList.itemDoubleClicked.connect(self.slotConnectHost)
self.ui.hostsList.itemClicked.connect(self.slotShowHost)
self.ui.hostsList.customContextMenuRequested.connect(self.slotShowHostContextMenu)
# set tab widget
self.tabWidget = MyTabWidget()
self.setCentralWidget(self.tabWidget)
self.tabWidget.setContextMenuPolicy(Qt.CustomContextMenu)
self.tabWidget.customContextMenuRequested.connect(self.showCentralWidgetContextMenu)
# set tray icon
self.tray = QSystemTrayIcon(QIcon(":/ico/myrdp.svg"))
self.tray.activated.connect(self.trayActivated)
self.trayMenu = QMenu()
self.trayMenu.addAction("Hide tray icon", self.changeTrayIconVisibility)
self.connectHostMenuTray = ConnectHostMenu(self.hosts)
self.connectHostMenuTray.triggered.connect(self.connectHostFromTrayMenu)
self.trayMenu.addMenu(self.connectHostMenuTray)
self.trayMenu.addAction("Quit", self.close)
self.tray.setContextMenu(self.trayMenu)
self.restoreSettings()
# host list
self.ui.filter.textChanged.connect(self.setHostList)
self.setHostList()
class MainWindow(QMainWindow):
groups = dict()
typeQListWidgetHeader = 1000
showHostsInGroups = False
currentGroupName = None # used to simple detect currently selected group to show menu
def __init__(self):
super(MainWindow, self).__init__()
self.config = Config()
self.db = Database(self.config.getConnectionString())
cryptoKey = self.getCryptoKey()
self.hosts = Hosts(self.db, cryptoKey)
# menu used for each host
self.hostMenu = QMenu()
self.editAction = QAction(QIcon(':/ico/edit.svg'), "Edit", self.hostMenu)
self.editAction.triggered.connect(self.editHost)
self.hostMenu.addAction(self.editAction)
# menu used for headers of groups
self.groupsHeaderMenu = QMenu()
self.editGroupAction = QAction(QIcon(':/ico/edit.svg'), "Edit group", self.groupsHeaderMenu)
self.editGroupAction.triggered.connect(self.editGroup)
self.deleteGroupAction = QAction(QIcon(':/ico/remove.svg'), "Delete group", self.groupsHeaderMenu)
self.deleteGroupAction.triggered.connect(self.deleteGroup)
self.groupsHeaderMenu.addAction(self.editGroupAction)
self.groupsHeaderMenu.addAction(self.deleteGroupAction)
self.duplicateAction = QAction(QIcon(':/ico/copy.svg'), "Duplicate", self.hostMenu)
self.duplicateAction.triggered.connect(self.duplicateHost)
self.hostMenu.addAction(self.duplicateAction)
# todo: confirm for delete action
self.deleteAction = QAction(QIcon(':/ico/remove.svg'), "Delete", self.hostMenu)
self.deleteAction.triggered.connect(self.deleteHost)
self.hostMenu.addAction(self.deleteAction)
self.connectFramelessMenu = actions.generateScreenChoseMenu(self.hostMenu, self.connectFrameless,
':/ico/frameless.svg', "Connect frameless")
self.hostMenu.addMenu(self.connectFramelessMenu)
self.assignGroupAction = QAction("Assign group", self.hostMenu)
self.assignGroupAction.triggered.connect(self.assignGroup)
self.hostMenu.addAction(self.assignGroupAction)
# setup main window
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# when top level changed, we changing dock title bar
self.dockWidgetTileBar = DockWidgetTitleBar()
self.ui.hostsDock.setTitleBarWidget(self.dockWidgetTileBar)
self.ui.hostsDock.topLevelChanged.connect(self.dockLevelChanged)
# set global menu
self.globalMenu = QMenu()
self.globalMenu.addAction(QIcon(':/ico/add.svg'), 'Add host', self.addHost)
# groups menu
self.groupsMenu = QMenu("Groups")
self.groupsMenu.aboutToShow.connect(self.setGroupsMenu)
self.globalMenu.addMenu(self.groupsMenu)
# disable menu indicator
self.ui.menu.setStyleSheet("QPushButton::menu-indicator {image: none;}")
self.positionMenu = QMenu("Dock position")
self.positionMenu.addAction("Left", lambda: self.setDockPosition(Qt.LeftDockWidgetArea))
self.positionMenu.addAction("Right", lambda: self.setDockPosition(Qt.RightDockWidgetArea))
self.positionMenu.addAction("Float", self.setDockFloat)
self.globalMenu.addMenu(self.positionMenu)
self.globalMenu.addAction('Change tray icon visibility', self.changeTrayIconVisibility)
self.globalMenu.addAction('Settings', self.showSettings)
self.globalMenu.addAction('Quit', self.close)
self.ui.menu.setMenu(self.globalMenu)
# set events on hosts list
self.ui.hostsList.itemDoubleClicked.connect(self.slotConnectHost)
self.ui.hostsList.itemClicked.connect(self.slotShowHost)
self.ui.hostsList.customContextMenuRequested.connect(self.slotShowHostContextMenu)
# set tab widget
self.tabWidget = MyTabWidget()
self.setCentralWidget(self.tabWidget)
self.tabWidget.setContextMenuPolicy(Qt.CustomContextMenu)
self.tabWidget.customContextMenuRequested.connect(self.showCentralWidgetContextMenu)
# set tray icon
self.tray = QSystemTrayIcon(QIcon(":/ico/myrdp.svg"))
self.tray.activated.connect(self.trayActivated)
self.trayMenu = QMenu()
self.trayMenu.addAction("Hide tray icon", self.changeTrayIconVisibility)
self.connectHostMenuTray = ConnectHostMenu(self.hosts)
self.connectHostMenuTray.triggered.connect(self.connectHostFromTrayMenu)
self.trayMenu.addMenu(self.connectHostMenuTray)
self.trayMenu.addAction("Quit", self.close)
self.tray.setContextMenu(self.trayMenu)
self.restoreSettings()
# host list
self.ui.filter.textChanged.connect(self.setHostList)
self.setHostList()
def getCryptoKey(self, passphrase=None):
try:
return self.config.getPrivateKey(passphrase)
except ValueError:
passwordDialog = PasswordDialog()
retCode = passwordDialog.exec_()
if retCode == QtGui.QDialog.Accepted:
return self.getCryptoKey(passwordDialog.getPassword())
else:
raise SystemError("Password required")
def showSettings(self):
settingsWidget = self.findChild(QWidget, "settings")
if settingsWidget is None:
self.settingsWidget = SettingsPage()
self.settingsWidget.setObjectName("settings")
self.tabWidget.insertTab(0, self.settingsWidget, QIcon(":/ico/settings.svg"), 'Settings')
index = self.tabWidget.indexOf(self.settingsWidget)
self.tabWidget.setCurrentIndex(index)
def connectHostFromMenu(self, action):
self.connectHost(unicode(action.text()))
def connectHostFromTrayMenu(self, action):
tabPage = self.connectHost(unicode(action.text()))
if not self.isVisible():
self.tabWidget.setDetached(True, tabPage)
def trayActivated(self, reason):
if reason != QSystemTrayIcon.Trigger:
return
if self.isVisible():
self.hide()
else:
self.show()
self.activateWindow()
def changeTrayIconVisibility(self):
if self.tray.isVisible():
self.tray.hide()
if not self.isVisible():
self.show()
else:
self.tray.show()
def refreshGroups(self):
groupList = self.hosts.getGroupsList()
for group in groupList:
if group not in self.groups:
# add new groups as visible
self.groups[group] = True
# remove not existing groups
keysToDelete = set(self.groups.keys()) - set(groupList)
for key in keysToDelete:
self.groups.pop(key)
def assignGroup(self):
groups = self.hosts.getGroupsList()
assignGroupDialog = AssignGroupDialog(groups)
groupToAssign = assignGroupDialog.assign()
if groupToAssign is not False: # None could be used to unassign the group
groupToAssign = None if groupToAssign.isEmpty() else unicode(groupToAssign)
for hostName in self.getSelectedHosts():
self.hosts.assignGroup(hostName, groupToAssign)
self.db.tryCommit()
self.setHostList()
def setGroupsMenu(self):
self.groupsMenu.clear()
addGroupAction = self.groupsMenu.addAction('Add group')
addGroupAction.triggered.connect(self.addGroup)
deleteGroupAction = self.groupsMenu.addAction('Delete group')
deleteGroupAction.triggered.connect(self.showDeleteGroupDialog)
showHostsInGroupsAction = self.groupsMenu.addAction('Show host list in groups')
showHostsInGroupsAction.triggered.connect(self.changeHostListView)
showHostsInGroupsAction.setCheckable(True)
showHostsInGroupsAction.setChecked(self.showHostsInGroups)
self.groupsMenu.addSeparator()
for group, checked in self.groups.items():
action = QAction(group, self.groupsMenu)
action.setCheckable(True)
action.setChecked(checked)
action.triggered.connect(self.groupsVisibilityChanged)
self.groupsMenu.addAction(action)
def addGroup(self):
groupConfigDialog = GroupConfigDialog(self.hosts.groups)
resp = groupConfigDialog.add()
self._processHostSubmit(resp)
def groupsVisibilityChanged(self, checked):
currentGroup = unicode(self.sender().text())
self.groups[currentGroup] = checked
self.setHostList()
def setDockPosition(self, dockWidgetArea):
if self.ui.hostsDock.isFloating():
self.ui.hostsDock.setFloating(False)
self.addDockWidget(dockWidgetArea, self.ui.hostsDock)
def setDockFloat(self):
if self.ui.hostsDock.isFloating():
return
# default title bar must be set before is float because sometimes window make strange crash
self.ui.hostsDock.setTitleBarWidget(None)
self.ui.hostsDock.setFloating(True)
def dockLevelChanged(self, isFloating):
if isFloating:
# changing title bar widget if is not none, probably true will be only once on start with saved float state
if self.ui.hostsDock.titleBarWidget():
self.ui.hostsDock.setTitleBarWidget(None)
else:
self.ui.hostsDock.setTitleBarWidget(self.dockWidgetTileBar)
def showFramelessWidget(self):
self.t.show()
self.t.setGeometry(self.frameGeometry())
def getCurrentHostListItemName(self):
return self.ui.hostsList.currentItem().text()
def getSelectedHosts(self):
return [host.text() for host in self.ui.hostsList.selectedItems()]
def findHostItemByName(self, name):
result = self.ui.hostsList.findItems(name, Qt.MatchExactly)
resultLen = len(result)
if resultLen != 1: # should be only one host
logger.error("Host not found. Got %d results" % resultLen)
return result[0]
def showCentralWidgetContextMenu(self, pos):
menu = QMenu()
title = self.ui.hostsDock.windowTitle()
hostsDockAction = menu.addAction(title)
hostsDockAction.setCheckable(True)
hostsDockAction.setChecked(self.ui.hostsDock.isVisible())
hostsDockAction.triggered.connect(self.changeHostsDockWidgetVisibility)
hostsDockAction = menu.addAction("Tray icon")
hostsDockAction.setCheckable(True)
hostsDockAction.setChecked(self.tray.isVisible())
hostsDockAction.triggered.connect(self.changeTrayIconVisibility)
connectHostMenuTray = ConnectHostMenu(self.hosts, "Connect")
connectHostMenuTray.triggered.connect(self.connectHostFromMenu)
menu.addMenu(connectHostMenuTray)
menu.exec_(self.tabWidget.mapToGlobal(pos))
def changeHostListView(self, checked):
self.showHostsInGroups = checked
self.setHostList()
def changeHostsDockWidgetVisibility(self):
isVisible = self.ui.hostsDock.isVisible()
self.ui.hostsDock.setVisible(not isVisible)
def isHostListHeader(self, item):
if not item or item.type() == self.typeQListWidgetHeader:
return True
return False
def slotShowHostContextMenu(self, pos):
def changeMenusVisibility(isEnabled):
self.connectFramelessMenu.setEnabled(isEnabled)
self.editAction.setEnabled(isEnabled)
self.duplicateAction.setEnabled(isEnabled)
# ignore context menu for group headers
item = self.ui.hostsList.itemAt(pos)
if self.isHostListHeader(item):
item = self.ui.hostsList.itemAt(pos)
widgetItem = self.ui.hostsList.itemWidget(item)
if widgetItem:
self.currentGroupName = widgetItem.text() # yea I'm so dirty
if self.currentGroupName != unassignedGroupName:
self.groupsHeaderMenu.exec_(self.ui.hostsList.mapToGlobal(pos))
return
if len(self.ui.hostsList.selectedItems()) == 1: # single menu
changeMenusVisibility(True)
else:
changeMenusVisibility(False)
self.hostMenu.exec_(self.ui.hostsList.mapToGlobal(pos))
def _processHostSubmit(self, resp):
if resp["code"]:
self.setHostList()
hostName = resp.get("name")
if hostName:
hostItem = self.findHostItemByName(hostName)
self.slotConnectHost(hostItem)
def addHost(self):
hostDialog = HostConfigDialog(self.hosts)
self._processHostSubmit(hostDialog.add())
def editHost(self):
hostDialog = HostConfigDialog(self.hosts)
resp = hostDialog.edit(self.getCurrentHostListItemName())
self._processHostSubmit(resp)
def editGroup(self):
groupConfigDialog = GroupConfigDialog(self.hosts.groups)
resp = groupConfigDialog.edit(self.currentGroupName)
self._processHostSubmit(resp)
def deleteGroup(self):
retCode = self.showOkCancelMessageBox("Do you want to remove selected group? All assigned hosts "
"to this group will be unassigned.",
"Confirmation")
if retCode == QMessageBox.Cancel:
return
self.hosts.deleteGroup(self.currentGroupName)
self.setHostList()
def showDeleteGroupDialog(self):
deleteGroupDialog = DeleteGroupDialog(self.hosts)
deleteGroupDialog.deleteGroup()
self.setHostList()
def duplicateHost(self):
hostDialog = HostConfigDialog(self.hosts)
resp = hostDialog.duplicate(self.getCurrentHostListItemName())
self._processHostSubmit(resp)
def deleteHost(self):
retCode = self.showOkCancelMessageBox("Do you want to remove selected hosts?",
"Confirmation")
if retCode == QMessageBox.Cancel:
return
for host in self.getSelectedHosts():
self.hosts.delete(host)
self.setHostList()
def connectFrameless(self, screenIndex=None):
self.connectHost(self.getCurrentHostListItemName(), frameless=True, screenIndex=screenIndex)
# Fix to release keyboard from QX11EmbedContainer, when we leave widget through wm border
def leaveEvent(self, event):
keyG = QWidget.keyboardGrabber()
if keyG is not None:
keyG.releaseKeyboard()
event.accept() # needed?
def setHostList(self):
""" set hosts list in list view """
self.ui.hostsList.clear()
self.refreshGroups()
hostFilter = self.ui.filter.text()
if self.showHostsInGroups:
self.showHostListInGroups(hostFilter)
else:
self.showHostList(hostFilter)
def showHostList(self, hostFilter):
groupFilter = [group for group, visibility in self.groups.items() if visibility]
hosts = self.hosts.getHostsListByHostNameAndGroup(hostFilter, groupFilter)
self.ui.hostsList.addItems(hosts)
def showHostListInGroups(self, hostFilter):
hosts = self.hosts.getGroupedHostNames(hostFilter)
for group, hostsList in hosts.items():
if self.groups.get(group, True):
if group is None:
group = unassignedGroupName
groupHeader = QtGui.QListWidgetItem(type=self.typeQListWidgetHeader)
groupLabel = QtGui.QLabel(unicode(group))
groupLabel.setProperty('class', 'group-title')
self.ui.hostsList.addItem(groupHeader)
self.ui.hostsList.setItemWidget(groupHeader, groupLabel)
self.ui.hostsList.addItems(hostsList)
def slotShowHost(self, item):
# on one click we activating tab and showing options
self.tabWidget.activateTab(item)
def slotConnectHost(self, item):
if self.isHostListHeader(item):
return
self.connectHost(unicode(item.text()))
def connectHost(self, hostId, frameless=False, screenIndex=None):
hostId = unicode(hostId) # sometimes hostId comes as QString
tabPage = self.tabWidget.createTab(hostId)
tabPage.reconnectionNeeded.connect(self.connectHost)
if frameless:
self.tabWidget.detachFrameless(tabPage, screenIndex)
try:
execCmd, opts = self.getCmd(tabPage, hostId)
except LookupError:
logger.error(u"Host {} not found.".format(hostId))
return
ProcessManager.start(hostId, tabPage, execCmd, opts)
return tabPage
def getCmd(self, tabPage, hostName):
host = self.hosts.get(hostName)
# set tabPage widget
width, height = tabPage.setSizeAndGetCurrent()
# 1et widget winId to embed rdesktop
winId = tabPage.x11.winId()
# set remote desktop client, at this time works only with freerdp
remoteClientType, remoteClientOptions = self.config.getRdpClient()
remoteClient = ClientFactory(remoteClientType, **remoteClientOptions)
remoteClient.setWindowParameters(winId, width, height)
remoteClient.setUserAndPassword(host.user, host.password)
remoteClient.setAddress(host.address)
return remoteClient.getComposedCommand()
def saveSettings(self):
self.config.setValue("geometry", self.saveGeometry())
self.config.setValue("windowState", self.saveState())
self.config.setValue('trayIconVisibility', self.tray.isVisible())
self.config.setValue('mainWindowVisibility', self.isVisible())
self.config.setValue('groups', self.groups)
self.config.setValue('showHostsInGroups', self.showHostsInGroups)
def restoreSettings(self):
try:
self.restoreGeometry(self.config.getValue("geometry").toByteArray())
self.restoreState(self.config.getValue("windowState").toByteArray())
except Exception:
logger.debug("No settings to restore")
# restore tray icon state
trayIconVisibility = self.config.getValue('trayIconVisibility', "true").toBool()
self.tray.setVisible(trayIconVisibility)
self.showHostsInGroups = self.config.getValue('showHostsInGroups', 'false').toBool()
if self.tray.isVisible():
mainWindowVisibility = self.config.getValue('mainWindowVisibility', "true").toBool()
self.setVisible(mainWindowVisibility)
else: # it tray icon is not visible, always show main window
self.show()
self.groups = {unicode(k): v for k, v in self.config.getValue('groups', {}).toPyObject().items()}
def closeEvent(self, event):
if not ProcessManager.hasActiveProcess:
self.saveSettings()
QCoreApplication.exit()
return
ret = self.showOkCancelMessageBox("Are you sure do you want to quit?",
"Exit confirmation")
if ret == QMessageBox.Cancel:
event.ignore()
return
self.saveSettings()
ProcessManager.killemall()
event.accept()
QCoreApplication.exit()
def showOkCancelMessageBox(self, messageBoxText, windowTitle):
msgBox = QMessageBox(self, text=messageBoxText)
msgBox.setWindowTitle(windowTitle)
msgBox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
msgBox.setIcon(QMessageBox.Question)
return msgBox.exec_()
def __init__(self, config):
super(MainWindow, self).__init__()
self.config = Config(config)
db = Database(self.config.getConnectionString())
db.create()
self.hosts = Hosts(db)
# menu used for each host
self.hostMenu = QMenu()
self.hostMenu.addAction(QIcon(":/ico/edit.svg"), "Edit", self.editHost)
self.hostMenu.addAction(QIcon(":/ico/remove.svg"), "Delete", self.deleteHost)
actions.addActionWithScreenChose(
self.hostMenu, self.connectFrameless, ":/ico/frameless.svg", "Connect frameless"
)
# setup main window
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# when top level changed, we changing dock title bar
self.dockWidgetTileBar = DockWidgetTitleBar()
self.ui.hostsDock.setTitleBarWidget(self.dockWidgetTileBar)
self.ui.hostsDock.topLevelChanged.connect(self.dockLevelChanged)
# set global menu
self.globalMenu = QMenu()
self.globalMenu.addAction(QIcon(":/ico/add.svg"), "Add host", self.addHost)
# disable menu indicator
self.ui.menu.setStyleSheet("QPushButton::menu-indicator {image: none;}")
self.positionMenu = QMenu("Dock position")
self.positionMenu.addAction("Left", lambda: self.setDockPosition(Qt.LeftDockWidgetArea))
self.positionMenu.addAction("Right", lambda: self.setDockPosition(Qt.RightDockWidgetArea))
self.positionMenu.addAction("Float", self.setDockFloat)
self.globalMenu.addMenu(self.positionMenu)
self.globalMenu.addAction("Change tray icon visibility", self.changeTrayIconVisibility)
self.globalMenu.addAction("Quit", self.close)
self.ui.menu.setMenu(self.globalMenu)
# set events on hosts list
self.ui.hostsList.itemDoubleClicked.connect(self.slotConnectHost)
self.ui.hostsList.itemClicked.connect(self.slotShowHost)
self.ui.hostsList.customContextMenuRequested.connect(self.slotShowHostContextMenu)
# set tab widget
self.tabWidget = MyTabWidget()
self.setCentralWidget(self.tabWidget)
# set tray icon
self.tray = QSystemTrayIcon(QIcon(":/ico/myrdp.svg"))
self.tray.activated.connect(self.trayActivated)
self.trayMenu = QMenu()
self.trayMenu.addAction("Hide tray icon", self.changeTrayIconVisibility)
self.trayMenu.addAction("Quit", self.close)
self.tray.setContextMenu(self.trayMenu)
# host list
self.ui.filter.textChanged.connect(self.setHostList)
self.setHostList()
self.restoreSettings()
def test_db(self):
db = Database(C.getConnectionString())
db.recreate()
rm = HostTable(name="xyz", address="192.168.6.66", user="******", password="******")
db.session.add(rm)
if __name__ == "__main__":
app = QApplication(sys.argv)
styleFile = QFile(":/style/style.qss")
styleFile.open(QFile.ReadOnly)
data = styleFile.readAll()
app.setStyleSheet(unicode(data))
# show icons in menus
app.setAttribute(Qt.AA_DontShowIconsInMenus, False)
app.setQuitOnLastWindowClosed(False)
# finish app with ctrl+c
signal.signal(signal.SIGINT, signal.SIG_DFL)
app.focusChanged.connect(focusChanged)
config = Config()
config.setLogLevel()
db = Database(config.getConnectionString())
db.create()
db.update()
mw = MainWindow()
app.exec_()
app.deleteLater()
sys.exit(0)
