def main():
global settings, hmqtt, log, imageHub, imageQ
# process args - port number,
ap = argparse.ArgumentParser()
ap.add_argument("-c",
"--conf",
required=True,
type=str,
help="path and name of the json configuration file")
args = vars(ap.parse_args())
# logging setup
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(message)s')
log = logging.getLogger('ML_Tracker')
settings = Settings(log, (args["conf"]))
hmqtt = Homie_MQTT(settings, ctrlCB)
settings.print()
# load the pre-computed models...
init_models()
log.info(f'listen on {settings.our_IP}:{settings.image_port}')
imageHub = imagezmq.ImageHub(open_port=f'tcp://*:{settings.image_port}')
imageQ = Queue.Queue(maxsize=60)
log.info('tracker running')
server = HTTPServer(('', 5000), CamHandler)
log.info("http server started")
server.serve_forever()
def __init__(self):
self._console = Console()
self._console.printLogo()
self._exceptionStack = list()
self._fileManager = FileManager()
self._logger = Logger()
self._settingsFile = Settings()
self._dialog = Dialog('en') if self._settingsFile.getLanguage(
) == '-' else Dialog(self._settingsFile.getLanguage())
#---------------------------------------------------------------------------------------------------------------#
# FILLING THE SETTINGS FILE WITH USER INPUT #
settingsMethods = self._settingsFile.getMethodsToResolveErrors()
for methodname, method in settingsMethods.items():
if methodname == "lang": # print a list of supporting languages and get user input for language setting
self._console.write(self._dialog.getMessageFor("chooseLang"))
langs = self._settingsFile.getSupportingLangs()
for key, value in langs.items():
self._console.write('[' + str(key) + ']')
self._console.write(value.upper() + ' ')
self._console.write('\n')
while (True):
langInput = int(self._console.readLine("\n--> "))
if langInput in langs.keys():
method(langs[langInput])
break
else:
self._console.writeLine(
self._dialog.getMessageFor("wrongInput"))
self._dialog.changeLanguage(self._settingsFile.getLanguage())
elif methodname == "username": # just get username fron input
while (True):
self._console.writeLine(
self._dialog.getMessageFor("getName"))
usernameInput = (self._console.readLine("\n--> "))
# checking the spelling of the username
if len(sub('[\t, \n, \r \s]', '', usernameInput)) >= 2:
method(usernameInput)
break
else:
continue
#---------------------------------------------------------------------------------------------------------------#
self._amelie = Amelie(self._settingsFile.getLanguage())
return
def main():
global isDarwin, settings, hmqtt, applog, audiodev
# process cmdline arguments
loglevels = ('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL')
ap = argparse.ArgumentParser()
ap.add_argument("-c",
"--conf",
required=True,
type=str,
help="path and name of the json configuration file")
ap.add_argument("-s",
"--syslog",
action='store_true',
default=False,
help="use syslog")
ap.add_argument("-d",
"--debug",
action='store',
type=int,
default='3',
nargs='?',
help="debug level, default is 3")
args = vars(ap.parse_args())
# logging setup
applog = logging.getLogger('mqttalarm')
#applog.setLevel(args['log'])
if args['syslog']:
applog.setLevel(logging.DEBUG)
handler = logging.handlers.SysLogHandler(address='/dev/log')
# formatter for syslog (no date/time or appname. Just msg.
formatter = logging.Formatter(
'%(name)s-%(levelname)-5s: %(message)-40s')
handler.setFormatter(formatter)
applog.addHandler(handler)
else:
logging.basicConfig(
level=logging.DEBUG,
datefmt="%H:%M:%S",
format='%(asctime)s %(levelname)-5s %(message)-40s')
audiodev = AudioDev()
isDarwin = audiodev.isDarwin
settings = Settings(args["conf"], audiodev, applog)
hmqtt = Homie_MQTT(settings, playUrl, chimeCb, sirenCb, strobeCb)
settings.print()
# fix debug levels
if args['debug'] == None:
debug_level = 3
else:
debug_level = args['debug']
# All we do now is loop over a 5 minute delay
while True:
time.sleep(5 * 60)
def __init__(self, parent):
self.parent = parent
self.tray_hints = {}
self.parent = parent
self.tray_hints = {}
self.gconf_client = Configuration()
self.start()
def __init__(self, usersProvider=None):
self.logger = Logger(__name__)
self.userProvider = usersProvider or UsersProvider()
self.settings = Settings().getSettings()
self.mysql = MySQLUserCreator()
self.fs = FileSystem()
self.mongoForgotPass = MongoForgotPassword()
def __init__(self, title=None, parent=None, record=None, selectedDate=None):
self.ui = gtk.Builder()
self.ui.add_from_file(os.path.join(common.DEFAULT_CFG_PATH, "add_bill.ui"))
self.window = self.ui.get_object("add_bill_dialog")
self.window.set_icon_from_file(common.APP_ICON)
if parent:
self.window.set_transient_for(parent)
# If we have a selected date, then set calendar to use it
if not selectedDate:
selectedDate = datetime.date.today()
self.selectedDate = selectedDate
self.gconf_client = Configuration()
# Private copy of any record passed
self.currentrecord = record
self.alarm = [None, None]
# TODO: This needs to be run BEFORE connecting the widgets
self._set_currency()
# Set up the UI
self._initialize_dialog_widgets()
self._populate_widgets()
self.category_index_before = 0
self.ui.connect_signals(self)
def __init__(self, parent):
self.parent = parent
self.tray_hints = {}
self.parent = parent
self.tray_hints = {}
self.gconf_client = Configuration()
self.start()
def __init__(self, name):
if 'UNITTESTING' in os.environ:
self.logging = NullLogger()
else:
settings = Settings().getSettings()
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=settings["logs"]["level"])
self.logging = logging.getLogger(name)
def __init__(self):
self.settings = Settings().getSettings()
self.user = None
self.firstname = None
self.surname = None
self.password = None
self.repassword = None
self.domain = None
self.email = None
def __init__(self, parent=None):
title = _("Preferences")
gtk.Dialog.__init__(self,
title=title,
parent=parent,
flags=gtk.DIALOG_MODAL
| gtk.DIALOG_DESTROY_WITH_PARENT
| gtk.DIALOG_NO_SEPARATOR,
buttons=(gtk.STOCK_CLOSE, gtk.RESPONSE_ACCEPT))
self.set_position(gtk.WIN_POS_CENTER)
self.set_border_width(6)
self.set_resizable(False)
self.set_icon_from_file(common.APP_ICON)
self.props.skip_taskbar_hint = True
self.gconf_client = Settings()
self._initialize_dialog_widgets()
self._populate_fields()
self._connect_fields()
self.connect("response", lambda self, *args: self.destroy())
def __init__(self):
# Initialize the game and settings from Settings class
pygame.init()
# Initialize the game screen in fullscreen mode
self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
# Creates instances of te other classes
self.settings = Settings(self)
self.playerscreen = Cards(self, "Player")
self.computerscreen = Cards(self, "Dealer")
self.pictures = Pictures(self)
# Deal first hand to each player
self.computerscreen.dealHand()
self.playerscreen.dealHand()
def __init__(self, parent=None):
title = _("Preferences")
gtk.Dialog.__init__(self, title=title, parent=parent,
flags=gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT |gtk.DIALOG_NO_SEPARATOR,
buttons=(gtk.STOCK_CLOSE, gtk.RESPONSE_ACCEPT))
self.set_position(gtk.WIN_POS_CENTER)
self.set_border_width(6)
self.set_resizable(False)
self.set_icon_from_file(common.APP_ICON)
self.props.skip_taskbar_hint = True
self.gconf_client = Settings()
self._initialize_dialog_widgets()
self._populate_fields()
self._connect_fields()
self.connect("response", lambda self, *args: self.destroy())
def __init__(self,
injected_open=None,
injected_eyeos_apps_storage=None,
injected_json=None,
injected_eyeos_apps_validator=None,
injected_application_api=None,
injected_principals_api=None,
injected_base_group=None,
injected_login_api=None):
self.eyeos_apps_storage = injected_eyeos_apps_storage or EyeosAppsStorage(
)
self.open = injected_open or open
self.json = injected_json or json
self.logger = Logger(__name__)
self.eyeos_apps_validator = injected_eyeos_apps_validator or EyeosAppsJsonValidator(
)
self.application_api = injected_application_api or Application()
self.principals_api = injected_principals_api or Principals()
self.principal_base_group = injected_base_group or Settings(
).getSettings()['principalservice']['base_group']
self.login_api = injected_login_api or Login()
class WaitForEyeos:
def __init__(self):
self.settings = Settings()
self.logger = Logger(__name__)
self.entrypoint = "proxy"
def wait(self, timeout):
logging.getLogger("requests").setLevel(logging.ERROR)
starttime = time.time()
while True:
now = time.time()
if now - starttime > timeout:
raise TimeoutError("Wait timed out")
try:
ip = self.settings.getServiceIp(self.entrypoint)
requests.get('http://{0}'.format(ip), verify=False)
time.sleep(5)
self.logger.info("Waited for {0} seconds".format(int(now - starttime)))
break
except (UnknownHostError, requests.exceptions.RequestException) as e:
time.sleep(0.5)
continue
def __init__(self,
title=None,
parent=None,
record=None,
selectedDate=None):
self.ui = gtk.Builder()
self.ui.add_from_file(
os.path.join(common.DEFAULT_CFG_PATH, "add_bill.ui"))
self.window = self.ui.get_object("add_bill_dialog")
self.window.set_icon_from_file(common.APP_ICON)
if parent:
self.window.set_transient_for(parent)
# If we have a selected date, then set calendar to use it
if not selectedDate:
selectedDate = datetime.date.today()
self.selectedDate = selectedDate
self.gconf_client = Configuration()
# Private copy of any record passed
self.currentrecord = record
self.alarm = [None, None]
# TODO: This needs to be run BEFORE connecting the widgets
self._set_currency()
# Set up the UI
self._initialize_dialog_widgets()
self._populate_widgets()
self.category_index_before = 0
self.ui.connect_signals(self)
class WaitForEyeos:
def __init__(self):
self.settings = Settings()
self.logger = Logger(__name__)
self.entrypoint = "proxy"
def wait(self, timeout):
logging.getLogger("requests").setLevel(logging.ERROR)
starttime = time.time()
while True:
now = time.time()
if now - starttime > timeout:
raise TimeoutError("Wait timed out")
try:
ip = self.settings.getServiceIp(self.entrypoint)
requests.packages.urllib3.disable_warnings()
requests.get('http://{0}'.format(ip), verify=False)
time.sleep(5)
self.logger.info("Waited for {0} seconds".format(int(now - starttime)))
break
except (UnknownHostError, requests.exceptions.RequestException) as e:
time.sleep(0.5)
continue
def __init__(self):
self.logger = Logger(__name__)
self.settings = Settings().getSettings()
def __init__(self):
self.settings = Settings().getSettings()
self.key_manager = KeyManager(paths.keys_path)
def __init__(self):
gobject.GObject.__init__(self)
if exists(join(USER_CFG_PATH, CFG_NAME)):
from lib.migrate_to_gconf import migrate
migrate(join(USER_CFG_PATH, CFG_NAME))
self.gconf_client = Configuration()
self.message = Message()
# Connects to the database
self.actions = Actions()
self.ui = gtk.Builder()
self.ui.add_from_file(os.path.join(DEFAULT_CFG_PATH, "main.ui"))
self.window = self.ui.get_object("main_window")
self.window.set_title("%s" % common.APPNAME)
self.window.set_icon_from_file(common.APP_ICON)
# ViewBill
self.list = ViewBill()
self.list.connect("cursor_changed", self._on_list_cursor_changed)
self.list.connect("row_activated", self._on_list_row_activated)
self.list.connect("button_press_event", self._on_list_button_press_event)
self.ui.get_object("bill_box").add(self.list)
# Toolbar
self.toolbar = self.ui.get_object("toolbar")
# Menubar
self._populate_menubar()
# Statusbar
self.statusbar = Statusbar()
self.ui.get_object("statusbar_box").add(self.statusbar)
# Restore timeline zoom
timeline_count = self.gconf_client.get("timeline_count")
# Timeline
self.timeline = Timeline(count=timeline_count, callback=self.on_timeline_cb)
self.timeline.connect("range-changed", self._on_timeline_changed)
self.timeline.connect("button-press-event", self._on_timeline_click)
self.timeline.connect("cleared", self._on_timeline_cleared)
self.ui.get_object("timeline_box").add(self.timeline)
# Chart
self.chart = ChartWidget()
self.chart.set_border_width(10)
self.ui.get_object("chart_box").add(self.chart)
# Restore position and size of window
width = self.gconf_client.get("window_width")
height = self.gconf_client.get("window_height")
x = self.gconf_client.get("window_position_x")
y = self.gconf_client.get("window_position_y")
if width and height:
self.window.resize(width, height)
if x and y:
self.window.move(x, y)
self.window.show_all()
# Whether to display toolbar or not
self.on_showToolbar_toggled(self.ui.get_object("showToolbar"))
self.list.grab_focus()
if self.gconf_client.get("start_in_tray"):
self.window.hide()
self.toggle_buttons()
# Connects to the Daemon
self.iface = None
iface = get_dbus_interface(common.DBUS_INTERFACE, common.DBUS_PATH)
if iface:
iface.connect_to_signal("bill_edited", self.reloadTreeView)
iface.connect_to_signal("bill_edited", self.reloadTimeline)
iface.connect_to_signal("show_main_window", self.window.show)
self.iface = iface
gobject.timeout_add(2000, self._send_tray_hints)
self.set_action_strings()
self.ui.connect_signals(self)
# populate treeview
self.reloadTreeView()
self.notify = NotifyIcon(self)
# Integrate with Ubuntu Unity
if UNITY:
self.unity = UnityIntegration(self)
def __init__(self, injected_proxy_ip=None, injected_eyeos_api_call=None):
self.settings = Settings().getSettings()
self.proxy_ip = injected_proxy_ip or self.settings['general']['public_hostname']
self.logger = Logger(__name__)
self.eyeos_api_call = injected_eyeos_api_call or EyeosApiCall()
class Alarm(object):
def __init__(self, parent):
self.parent = parent
self.tray_hints = {}
self.parent = parent
self.tray_hints = {}
self.gconf_client = Configuration()
self.start()
def start(self):
start_delay = self.gconf_client.get('startup_delay')
print start_delay
showStartup = self.gconf_client.get('show_startup_notification')
print showStartup
if showStartup:
timeout_add(start_delay, self.show_pay_notification)
timeout_add(start_delay + 12000, self.verify_due)
interval = self.gconf_client.get('interval')
print interval
if interval:
timeout_add(interval, self.timer)
def notification(self, title, body):
notify = NotifyMessage(self.parent)
notify.title = title
notify.body = body
notify.set_timeout(20)
notify.set_default_action(self.__cb_launch_gui)
notify.hints = self.tray_hints
return notify
def show_pay_notification(self):
print "Got here 3"
today = datetime.datetime.today()
limit = self.gconf_client.get('notification_days_limit')
print limit
limit = datetime.timedelta(days=limit)
end = today + limit
if limit:
records = self.parent.actions.get_interval_bills(end=end,
paid=False)
#'dueDate <= %s AND paid = 0' % (today + limit))
else:
print "No limit"
records = self.parent.actions.get_bills(paid=False)
msg = ngettext('You have %s outstanding bill to pay!',
'You have %s outstanding bills to pay!',
len(records)) % len(records)
if msg and records:
bubble = self.notification(common.APPNAME, msg)
bubble.add_action("view", _("Show BillReminder"),
self.__cb_launch_gui, None)
#bubble.add_action("close", _("Cancel"), None)
bubble.show()
return False
def verify_due(self, sum=0):
print "Got here 2"
showDueAlarm = self.gconf_client.get('show_due_alarm')
print showDueAlarm
if not showDueAlarm:
print "Do not show due alarm"
return
today = datetime.datetime.today()
if sum > 0:
records = self.parent.actions.get_interval_bills(
today, today, False)
else:
records = self.parent.actions.get_interval_bills(end=today,
paid=False)
i = 1
use_dialog = self.gconf_client.get('use_alert_dialog')
print use_dialog
# TODO: use only one dialog for all bills, if use_dialog == True
for bill in records:
if sum > 0:
# date format string
dtformat = locale.nl_langinfo(locale.D_FMT)
# date from record in timestamp format
dtstamp = bill.dueDate
# record dictionary
recDict = {
'bill':
"<b>\"%s\"</b>" % bill.payee,
'day':
"<b>\"%s\"</b>" %
dtstamp.strftime(dtformat).encode('ASCII')
}
# TODO: calculate days
timeout_add(
i * 12000, self.show_bill_notification, bill,
_("The bill %(bill)s will be due at %(day)s.") % recDict,
use_dialog)
else:
timeout_add(i * 12000, self.show_bill_notification, bill, None,
use_dialog)
i += 1
def show_bill_notification(self,
bill=None,
msg=None,
alert=False,
timeout=None):
if msg is None:
msg = _('The bill %s is due.') % "<b>\"%s\"</b>" % bill.payee
if not self.parent.actions.get_bills(id=bill.id)[0].paid:
if alert:
alert = Message().ShowBillInfo(
text=msg, title=_("BillReminder Notifier"))
if alert == RESPONSE_YES:
self.__cb_mark_as_paid(None, (bill, ))
elif alert == RESPONSE_NO:
self.__cb_edit_bill(None, (bill, ))
else:
bubble = self.notification(common.APPNAME, msg)
bubble.add_action("paid", _("Mark as paid"),
self.__cb_mark_as_paid, bill)
bubble.add_action("edit", _("Edit"), self.__cb_edit_bill, bill)
#bubble.add_action("close", _("Cancel"), None)
if timeout:
bubble.set_timeout(timeout)
bubble.show()
return False
def __cb_launch_gui(self, *arg):
# If client is not running, launch it
# Send DBus 'show_main_window' signal
self.parent.dbus_server.show_main_window()
if not self.parent.client_pid or \
not verify_pid(self.parent.client_pid):
gui = Popen('billreminder', shell=True)
self.parent.client_pid = gui.pid
def __cb_mark_as_paid(self, *arg):
record = arg[1][0]
if record:
record.paid = True
try:
# Edit bill to database
self.parent.dbus_server.edit_bill(record)
except Exception, e:
print "Error #1"
print str(e)
class PrefDialog(gtk.Dialog):
"""
Class used to generate dialog to allow user to edit preferences.
"""
def __init__(self, parent=None):
title = _("Preferences")
gtk.Dialog.__init__(self, title=title, parent=parent,
flags=gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT |gtk.DIALOG_NO_SEPARATOR,
buttons=(gtk.STOCK_CLOSE, gtk.RESPONSE_ACCEPT))
self.set_position(gtk.WIN_POS_CENTER)
self.set_border_width(6)
self.set_resizable(False)
self.set_icon_from_file(common.APP_ICON)
self.props.skip_taskbar_hint = True
self.gconf_client = Settings()
self._initialize_dialog_widgets()
self._populate_fields()
self._connect_fields()
self.connect("response", lambda self, *args: self.destroy())
def _initialize_dialog_widgets(self):
self.topcontainer = gtk.VBox(homogeneous=False, spacing=18)
self.topcontainer.set_border_width(6)
# Alert Group
alertFrame = gtk.VBox(homogeneous=False, spacing=6)
alertAlignment = gtk.Alignment()
alertAlignment.set_padding(0, 0, 12, 0)
title = gtk.Label()
title.set_markup(_("<b>Alarms</b>"))
title.set_alignment(0.00, 0.50)
alertFrame.pack_start(title)
alertFrame.pack_start(alertAlignment)
alertContainer = gtk.VBox(homogeneous=False, spacing=6)
self.alertCheckbox = gtk.CheckButton(_('_Alert before due date:'), use_underline=True)
self.alertSpinButton = gtk.SpinButton()
self.alertSpinButton.set_range(0, 360)
self.alertSpinButton.spin(gtk.SPIN_STEP_FORWARD)
self.alertSpinButton.set_increments(1, 7)
alertDays = gtk.Label("%s" % _('day(s).'))
self.notificationTime = TimeWidget()
alertPreferredTime = gtk.Label()
alertPreferredTime.set_markup_with_mnemonic(_('_Preferred time:'))
alertPreferredTime.set_mnemonic_widget(self.notificationTime.hourSpinner)
alertPreferredTime.set_alignment(0.00, 0.50)
alertDefinition = gtk.Label(_('Get alerted when individual bills are due.'))
alertDefinition.set_alignment(0.00, 0.90)
# Add label defining what an alarm means.
alertContainer.pack_start(alertDefinition, expand=False, fill=True, padding=0)
# Container for alert checkbox and spin button for day selection.
hbox = gtk.HBox(homogeneous=False, spacing=4)
hbox.pack_start(self.alertCheckbox, expand=False, fill=True, padding=0)
hbox.pack_start(self.alertSpinButton, expand=False, fill=False, padding=0)
hbox.pack_start(alertDays, expand=False, fill=False, padding=0)
alertContainer.pack_start(hbox, expand=False, fill=True, padding=0)
# Container for preferred time for alerts.
hbox = gtk.HBox(homogeneous=False, spacing=12)
hbox.pack_start(alertPreferredTime, expand=False, fill=True, padding=0)
hbox.pack_start(self.notificationTime, expand=True, fill=True, padding=0)
alertContainer.pack_start(hbox, expand=False, fill=True, padding=0)
alertAlignment.add(alertContainer)
# Notification Group
notifyFrame = gtk.VBox(homogeneous=False, spacing=6)
title = gtk.Label()
title.set_markup(_("<b>Notifications</b>"))
title.set_alignment(0.00, 0.50)
notifyAlignment = gtk.Alignment()
notifyAlignment.set_padding(0, 0, 12, 0)
notifyFrame.pack_start(title)
notifyFrame.pack_start(notifyAlignment)
notificationDefinition = gtk.Label(_('Define when to be notified of upcoming bills.'))
notificationDefinition.set_alignment(0.00, 0.90)
notificationsContainer = gtk.VBox(homogeneous=False, spacing=6)
# Add label defining what a definition means.
notificationsContainer.pack_start(notificationDefinition, expand=False, fill=False, padding=0)
self.notifyCheckbox = gtk.CheckButton(_('_Notify before due date:'),
use_underline=True)
self.notifySpinButton = gtk.SpinButton()
self.notifySpinButton.set_range(0, 360)
self.notifySpinButton.spin(gtk.SPIN_STEP_FORWARD)
self.notifySpinButton.set_increments(1, 7)
notifyDays = gtk.Label("%s" % _('day(s).'))
# Container for notification checkbox and spin button for day selection.
hbox = gtk.HBox(homogeneous=False, spacing=4)
hbox.pack_start(self.notifyCheckbox, expand=False, fill=True, padding=0)
hbox.pack_start(self.notifySpinButton, expand=False, fill=False, padding=0)
hbox.pack_start(notifyDays, expand=False, fill=False, padding=0)
notificationsContainer.pack_start(hbox, expand=False, fill=True, padding=0)
notifyAlignment.add(notificationsContainer)
# Alert Type Group
alertTypeFrame = gtk.VBox(homogeneous=False, spacing=6)
title = gtk.Label()
title.set_markup(_("<b>Alert Type</b>"))
title.set_alignment(0.00, 0.50)
alertTypeAlignment = gtk.Alignment()
alertTypeAlignment.set_padding(0, 0, 12, 0)
alertTypeFrame.pack_start(title)
alertTypeFrame.pack_start(alertTypeAlignment)
vbox = gtk.VBox(homogeneous=False, spacing=6)
hbox = gtk.HBox(homogeneous=False, spacing=12)
self.alertBubble = gtk.RadioButton(label=_("Notification _Bubble"))
self.alertDialog = gtk.RadioButton(group=self.alertBubble,
label=_("Alert _Dialog"))
hbox.pack_start(self.alertBubble, expand=False, fill=False, padding=0)
hbox.pack_start(self.alertDialog, expand=False, fill=False, padding=0)
vbox.pack_start(hbox, expand=False, fill=False, padding=0)
alertTypeAlignment.add(vbox)
# Daemon Warning
daemonContainer = gtk.VBox(homogeneous=False, spacing=6)
self.daemonLabel = gtk.Label(
_("<b>Warning:</b> BillReminder Notifier is \n" \
"not running! You need to start it in order \n" \
" to receive notifications."))
self.daemonLabel.set_justify(gtk.JUSTIFY_CENTER)
self.daemonLabel.set_use_markup(True)
daemonImage = gtk.Image()
daemonImage.set_from_stock('gtk-execute', 2)
self.daemonButton = gtk.Button(label=_("_Start BillReminder Notifier"))
self.daemonButton.set_relief(gtk.RELIEF_NONE)
self.daemonButton.set_image(daemonImage)
daemonContainer.pack_start(self.daemonLabel, expand=False, fill=True, padding=0)
daemonContainer.pack_start(self.daemonButton, expand=False, fill=True, padding=0)
# Everything
self.topcontainer.pack_start(alertFrame, expand=False, fill=True, padding=0)
self.topcontainer.pack_start(notifyFrame, expand=False, fill=True, padding=0)
self.topcontainer.pack_start(alertTypeFrame, expand=False, fill=True, padding=0)
if not utils.verify_dbus_service(common.DBUS_INTERFACE):
self.topcontainer.pack_start(daemonContainer, expand=False, fill=True, padding=0)
self.vbox.pack_start(self.topcontainer, expand=False, fill=True)
self.show_all()
def _populate_fields(self):
self.notifyCheckbox.set_active(self.gconf_client.get('show_before_alarm'))
self.alertCheckbox.set_active(self.gconf_client.get('show_alarm'))
if not self.gconf_client.get('use_alert_dialog'):
self.alertBubble.set_active(True)
else:
self.alertDialog.set_active(True)
# Number of days before showing alarm
adays = self.gconf_client.get('notification_days_limit')
self.notifySpinButton.set_value(adays and adays or 3)
self.alertSpinButton.set_value(self.gconf_client.get('show_alarm_before_days'))
atime = self.gconf_client.get('show_alarm_at_time')
atime = atime.split(":")
self.notificationTime.setHourMinute(atime[0], atime[1])
def _connect_fields(self):
self.notificationTime.hourSpinner.connect("value_changed", self._on_time_changed)
self.notificationTime.minuteSpinner.connect("value_changed", self._on_time_changed)
self.notifyCheckbox.connect("toggled",
self._on_checkbox_toggled, 'show_before_alarm')
self.alertCheckbox.connect("toggled",
self._on_checkbox_toggled, 'show_alarm')
self.notifySpinButton.connect("changed",
self._on_spin_changed, 'notification_days_limit')
self.alertSpinButton.connect("changed",
self._on_spin_changed, 'show_alarm_before_days')
self.alertDialog.connect("toggled",
self._on_checkbox_toggled, 'use_alert_dialog')
self.daemonButton.connect("clicked", self._launch_daemon)
def _on_time_changed(self, spin):
alarm = self.notificationTime.getTime()
alarm = ":".join(["%.02d" % x for x in alarm])
self.gconf_client.set('show_alarm_at_time', alarm)
def _on_checkbox_toggled(self, togglebutton, item):
self.gconf_client.set(item, togglebutton.get_active())
def _on_spin_changed(self, obj, item):
self.gconf_client.set(item, int(obj.get_value()))
def _launch_daemon(self, button):
Popen('billreminderd', shell=True)
button.hide()
self.daemonLabel.set_markup( _("<b>Note:</b> BillReminder Notifier is now running."))
def __init__(self):
self.settings = Settings()
self.logger = Logger(__name__)
self.entrypoint = "proxy"
class AddDialog(object):
"""
Class used to generate dialog to allow user to enter/edit records.
"""
def __init__(self,
title=None,
parent=None,
record=None,
selectedDate=None):
self.ui = gtk.Builder()
self.ui.add_from_file(
os.path.join(common.DEFAULT_CFG_PATH, "add_bill.ui"))
self.window = self.ui.get_object("add_bill_dialog")
self.window.set_icon_from_file(common.APP_ICON)
if parent:
self.window.set_transient_for(parent)
# If we have a selected date, then set calendar to use it
if not selectedDate:
selectedDate = datetime.date.today()
self.selectedDate = selectedDate
self.gconf_client = Configuration()
# Private copy of any record passed
self.currentrecord = record
self.alarm = [None, None]
# TODO: This needs to be run BEFORE connecting the widgets
self._set_currency()
# Set up the UI
self._initialize_dialog_widgets()
self._populate_widgets()
self.category_index_before = 0
self.ui.connect_signals(self)
def _set_currency(self):
self.decimal_sep = locale.localeconv()['mon_decimal_point']
self.thousands_sep = locale.localeconv()['mon_thousands_sep']
self.allowed_digts = [self.decimal_sep, self.thousands_sep]
self.allowed_digts += [str(i) for i in range(10)]
def _initialize_dialog_widgets(self):
self.frequency = self.ui.get_object("frequency")
self.dueDate = DatePicker()
self.ui.get_object("due_date_box").add(self.dueDate)
self.dueDate.connect('date_changed', self._on_datepicker_date_changed)
self.endDate = DatePicker()
self.ui.get_object("end_date_box").add(self.endDate)
self.endDate.connect('date_changed', self._on_datepicker_date_changed)
self.payee = self.ui.get_object("payee")
self.payeecompletion = gtk.EntryCompletion()
self.payee.child.set_completion(self.payeecompletion)
self.amount = self.ui.get_object("amount")
self.category = self.ui.get_object("category")
px = gtk.CellRendererPixbuf()
txt = gtk.CellRendererText()
self.category.pack_start(px, False)
self.category.pack_start(txt, False)
self.category.add_attribute(px, "pixbuf", 0)
self.category.add_attribute(txt, "text", 1)
self.category.set_row_separator_func(self._determine_separator)
self.categorybutton = self.ui.get_object("edit_categories")
self.notes = self.ui.get_object("notes")
self.txtbuffer = self.notes.get_buffer()
self.alarmbutton = DateButton(self.window)
self.alarmbutton.set_tooltip_text(_("Select Date and Time"))
self.ui.get_object("alarm_button_box").add(self.alarmbutton)
self.ui.get_object("alarm_label").set_mnemonic_widget(self.alarmbutton)
self.window.show_all()
def _populate_widgets(self):
""" Populate dialog widgets so they can be used. """
self._populate_frequency()
self._populate_payee() # Populate combobox with payee from db
self._populate_category() # Populate combobox with category from db
# If a record was passed, we're in edit mode
if self.currentrecord:
self._populate_widgets_with_record()
#in edit mode we must disable repetition
self.frequency.set_sensitive(False)
self.endDate.set_sensitive(False)
else:
self.dueDate.set_date(self.selectedDate)
self.endDate.set_date(self.selectedDate)
# Use alarm values from preferences
showalarm = self.gconf_client.get('show_alarm')
atime = self.gconf_client.get('show_alarm_at_time')
adays = self.gconf_client.get('show_alarm_before_days')
if showalarm:
alarmDate = scheduler.get_alarm_timestamp(
adays, atime, self.selectedDate)
self.alarmbutton.set_date(alarmDate)
def _determine_separator(self, model, iter, data=None):
return model.get_value(iter, 1) == "---"
def _populate_widgets_with_record(self):
# Format the amount field
if self.currentrecord.amount:
self.amount.set_text(
utils.float_to_currency(self.currentrecord.amount))
else:
self.amount.set_text("")
# Format the dueDate field
dt = self.currentrecord.dueDate
self.dueDate.set_date(dt)
utils.select_combo_text(self.payee, self.currentrecord.payee)
if self.currentrecord.category:
actions = Actions()
cat_name = self.currentrecord.category.name
records = actions.get_categories(name=cat_name)
if records:
categoryname = records[0].name
utils.select_combo_text(self.category, categoryname, 1)
else:
self.category.set_active(0)
if self.currentrecord.notes:
self.txtbuffer.set_text(self.currentrecord.notes)
#self.chkPaid.set_active(self.currentrecord.Paid)
if self.currentrecord.alarmDate:
self.alarmbutton.set_date(self.currentrecord.alarmDate)
def _populate_payee(self):
""" Populates combobox with existing payees """
# Connects to the database
actions = Actions()
# List of payees from database
payees = []
records = actions.get_bills()
for rec in records:
if rec.payee not in payees:
payees.append(rec.payee)
store = gtk.ListStore(gobject.TYPE_STRING)
for payee in payees:
store.append([payee])
self.payee.set_model(store)
self.payeecompletion.set_model(store)
self.payee.set_text_column(0)
self.payeecompletion.set_text_column(0)
self.payeeEntry = self.payee.child
self.selectedText = ''
def _get_payee(self):
""" Extracts information typed into comboboxentry """
if self.payee.get_active_iter() is not None:
model = self.payee.get_model()
iteration = self.payee.get_active_iter()
if iteration:
return model.get_value(iteration, 0)
else:
return self.payeeEntry.get_text()
def _populate_frequency(self):
""" Populates combobox with allowable frequency. """
store = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_INT)
self.frequency.set_model(store)
cell = gtk.CellRendererText()
self.frequency.pack_start(cell, True)
self.frequency.add_attribute(cell, 'text', 0)
for i, frequency in enumerate(
[scheduler.SC_ONCE, scheduler.SC_MONTHLY, scheduler.SC_WEEKLY]):
store.append([frequency, i])
# Set SC_ONCE as default
self.frequency.set_active(0)
self.on_frequency_changed(self.frequency)
def _populate_category(self, categoryname=None):
""" Populates combobox with existing categories """
# Connects to the database
actions = Actions()
# List of categories from database
categories = []
records = actions.get_categories()
ret = 0
empty_color = create_pixbuf()
for rec in records:
#if [rec['categoryname'], rec['id']] not in categories:
#TODO: Better put color creation in a function
color = rec.color and rec.color or '#000'
categories.append(
[create_pixbuf(color=color), rec.name,
int(rec.id)])
if categoryname and categoryname == rec.name:
ret = len(categories) + 1
store = gtk.ListStore(gtk.gdk.Pixbuf, str, int)
self.category.set_model(store)
store.append([empty_color, _("None"), 0])
store.append([None, "---", -1])
for category in categories:
store.append(category)
store.append([None, "---", -1])
store.append([empty_color, _("New Category"), -2])
self.category.set_active(ret)
return ret
def _get_category(self):
""" Extracts information typed into comboboxentry """
actions = Actions()
if self.category.get_active_iter() is not None:
model = self.category.get_model()
iteration = self.category.get_active_iter()
if iteration:
name = model.get_value(iteration, 1)
else:
name = None
if not name or name == _("None"):
return None
records = actions.get_categories(name=name)
if records:
return records[0]
else:
return None
def get_record(self):
frequency = self.frequency.get_active_text()
# Extracts the date off the calendar widget
# Create datetime object
selectedDate = self.dueDate.get_date()
# End date
if frequency != scheduler.SC_ONCE:
endDate = self.endDate.get_date()
# Notify user that the endDate is set in the past
if endDate < selectedDate:
endDate = selectedDate
message = utils.Message()
text = _(
"The end date is set to a date prior to the start date. Setting it to match the start date."
)
title = _("Date set in the past")
message.ShowInfo(text=text,
parentWindow=self.window,
title=title)
else:
endDate = None
#buffer = self.txtNotes.get_buffer()
startiter, enditer = self.txtbuffer.get_bounds()
sbuffer = self.txtbuffer.get_text(startiter, enditer)
# Gets the payee
payee = self._get_payee()
# Gets the category
category = self._get_category()
# Gets the alarm date
alarm = self.alarmbutton.get_date() or None
# Validate form
if not payee.strip():
return None
if self.amount.get_text().strip():
amount = utils.currency_to_float(self.amount.get_text())
else:
amount = None
if self.currentrecord is None:
# Verify how many bills will be inserted
# this will only work for new bills
records = []
# Figures out how many times we're repeating this bill
days = scheduler.get_schedule_date(frequency, selectedDate,
endDate)
for day in days:
if alarm:
alarm = self.__get_alarm_date(day)
rec = Bill(payee=payee,
amount=amount,
dueDate=day,
alarmDate=alarm,
notes=sbuffer,
repeats=False)
# Bill repeats...
if len(days) > 1:
rec.repeats = True
# ... and has a category.
if category:
rec.category = category
records.append(rec)
return records
else:
# Edit existing bill
self.currentrecord.payee = payee
self.currentrecord.dueDate = selectedDate
self.currentrecord.amount = amount
self.currentrecord.notes = sbuffer
self.currentrecord.alarmDate = alarm
if category:
self.currentrecord.category = category
#return the bill
return [self.currentrecord]
def on_frequency_changed(self, widget):
startDate = self.dueDate.get_date()
endDate = self.endDate.get_date()
frequency = widget.get_active_text()
if frequency == scheduler.SC_ONCE:
self.endDate.set_sensitive(False)
else:
self.endDate.set_sensitive(True)
if startDate > endDate:
self.endDate.set_date(self.dueDate.get_date())
def on_edit_categories_clicked(self, button, new=False):
category = None
# if new == True, a simpler categories dialog pops up
self.window.category = self.category
categories = CategoriesDialog(parent=self.window, new=new)
ret = categories.run()
if ret == gtk.RESPONSE_OK:
#TODO: We should handle the saving in the dialog itself.
# the category hasn't been saved yet... so save it.
if new:
categories._on_savebutton_clicked(None)
category = categories.currentrecord
categories.destroy()
# Always re-populate the categories dropdown widget, regardless if
# newer category was added. If something was returned, select it.
if category:
self._populate_category(category.name)
else:
self._populate_category()
return ret
def on_category_changed(self, combobox):
index = self.category.get_active()
model = self.category.get_model()
if index == len(model) - 1:
self.category.set_active(self.category_index_before)
self.on_edit_categories_clicked(combobox, True)
self.category_index_before = index
def on_amount_insert_text(self, entry, string, len, position):
for char in string:
if char not in self.allowed_digts:
print "Invalid Character: %s" % char
entry.emit_stop_by_name("insert-text")
gtk.gdk.beep()
return
def on_save_clicked(self, widget):
message = utils.Message()
startDate = self.dueDate.get_date()
endDate = self.endDate.get_date()
if not self._get_payee().strip() and \
not self.amount.get_text().strip():
message.ShowError(_("\"%s\" and \"%s\" are required fields.") \
% (_("Payee"), _("Amount")), self.window)
self.payee.grab_focus()
elif not self._get_payee().strip():
message.ShowError(
_("\"%s\" is required field.") % _("Payee"), self.window)
self.payee.grab_focus()
elif not self.amount.get_text().strip():
message.ShowError(
_("\"%s\" is required field.") % _("Amount"), self.window)
self.amount.grab_focus()
elif self.endDate.get_sensitive() and startDate > endDate:
message.ShowError(
_("The end date is set to a date prior to the start date."),
self.window)
else:
self.window.response(gtk.RESPONSE_ACCEPT)
def _on_datepicker_date_changed(self, widget, args):
startDate = self.dueDate.get_date()
endDate = self.endDate.get_date()
if widget == self.dueDate:
if self.endDate.get_sensitive() and startDate > endDate:
# Update endDate to be equal to dueDate
self.endDate.set_date(self.dueDate.get_date())
else:
if self.endDate.get_sensitive():
if startDate > endDate:
# Update endDate to be equal to dueDate
self.endDate.set_date(self.dueDate.get_date())
if self.alarmbutton.get_date():
# Extracts the date off the datepicker widget
alarmDate = self.__get_alarm_date(self.dueDate.get_date())
self.alarmbutton.set_date(alarmDate)
def __get_alarm_date(self, date):
# Use alarm values from preferences
atime = self.gconf_client.get('show_alarm_at_time')
adays = self.gconf_client.get('show_alarm_before_days')
return scheduler.get_alarm_timestamp(adays, atime, date)
def __init__(self, proxy_ip=None, injected_eyeos_api_call=None):
self.proxy_ip = proxy_ip or Settings().getServiceIp('proxy')
self.systemgroups_url = 'https://{0}/systemgroups/v1/systemgroups'.format(
self.proxy_ip)
self.logger = Logger(__name__)
self.eyeos_api_call = injected_eyeos_api_call or EyeosApiCall()
class AddDialog(object):
"""
Class used to generate dialog to allow user to enter/edit records.
"""
def __init__(self, title=None, parent=None, record=None, selectedDate=None):
self.ui = gtk.Builder()
self.ui.add_from_file(os.path.join(common.DEFAULT_CFG_PATH, "add_bill.ui"))
self.window = self.ui.get_object("add_bill_dialog")
self.window.set_icon_from_file(common.APP_ICON)
if parent:
self.window.set_transient_for(parent)
# If we have a selected date, then set calendar to use it
if not selectedDate:
selectedDate = datetime.date.today()
self.selectedDate = selectedDate
self.gconf_client = Configuration()
# Private copy of any record passed
self.currentrecord = record
self.alarm = [None, None]
# TODO: This needs to be run BEFORE connecting the widgets
self._set_currency()
# Set up the UI
self._initialize_dialog_widgets()
self._populate_widgets()
self.category_index_before = 0
self.ui.connect_signals(self)
def _set_currency(self):
self.decimal_sep = locale.localeconv()['mon_decimal_point']
self.thousands_sep = locale.localeconv()['mon_thousands_sep']
self.allowed_digts = [self.decimal_sep , self.thousands_sep]
self.allowed_digts += [str(i) for i in range(10)]
def _initialize_dialog_widgets(self):
self.frequency = self.ui.get_object("frequency")
self.dueDate = DatePicker()
self.ui.get_object("due_date_box").add(self.dueDate)
self.dueDate.connect('date_changed', self._on_datepicker_date_changed)
self.endDate = DatePicker()
self.ui.get_object("end_date_box").add(self.endDate)
self.endDate.connect('date_changed', self._on_datepicker_date_changed)
self.payee = self.ui.get_object("payee")
self.payeecompletion = gtk.EntryCompletion()
self.payee.child.set_completion(self.payeecompletion)
self.amount = self.ui.get_object("amount")
self.category = self.ui.get_object("category")
px = gtk.CellRendererPixbuf()
txt = gtk.CellRendererText()
self.category.pack_start(px, False)
self.category.pack_start(txt, False)
self.category.add_attribute(px, "pixbuf", 0)
self.category.add_attribute(txt, "text", 1)
self.category.set_row_separator_func(self._determine_separator)
self.categorybutton = self.ui.get_object("edit_categories")
self.notes = self.ui.get_object("notes")
self.txtbuffer = self.notes.get_buffer()
self.alarmbutton = DateButton(self.window)
self.alarmbutton.set_tooltip_text(_("Select Date and Time"))
self.ui.get_object("alarm_button_box").add(self.alarmbutton)
self.ui.get_object("alarm_label").set_mnemonic_widget(self.alarmbutton)
self.window.show_all()
def _populate_widgets(self):
""" Populate dialog widgets so they can be used. """
self._populate_frequency()
self._populate_payee() # Populate combobox with payee from db
self._populate_category() # Populate combobox with category from db
# If a record was passed, we're in edit mode
if self.currentrecord:
self._populate_widgets_with_record()
#in edit mode we must disable repetition
self.frequency.set_sensitive(False)
self.endDate.set_sensitive(False)
else:
self.dueDate.set_date(self.selectedDate)
self.endDate.set_date(self.selectedDate)
# Use alarm values from preferences
showalarm = self.gconf_client.get('show_alarm')
atime = self.gconf_client.get('show_alarm_at_time')
adays = self.gconf_client.get('show_alarm_before_days')
if showalarm:
alarmDate = scheduler.get_alarm_timestamp(adays, atime, self.selectedDate)
self.alarmbutton.set_date(alarmDate)
def _determine_separator(self, model, iter, data=None):
return model.get_value(iter, 1) == "---"
def _populate_widgets_with_record(self):
# Format the amount field
if self.currentrecord.amount:
self.amount.set_text(utils.float_to_currency(self.currentrecord.amount))
else:
self.amount.set_text("")
# Format the dueDate field
dt = self.currentrecord.dueDate
self.dueDate.set_date(dt)
utils.select_combo_text(self.payee, self.currentrecord.payee)
if self.currentrecord.category:
actions = Actions()
cat_name = self.currentrecord.category.name
records = actions.get_categories(name=cat_name)
if records:
categoryname = records[0].name
utils.select_combo_text(self.category, categoryname, 1)
else:
self.category.set_active(0)
if self.currentrecord.notes:
self.txtbuffer.set_text(self.currentrecord.notes)
#self.chkPaid.set_active(self.currentrecord.Paid)
if self.currentrecord.alarmDate:
self.alarmbutton.set_date(self.currentrecord.alarmDate)
def _populate_payee(self):
""" Populates combobox with existing payees """
# Connects to the database
actions = Actions()
# List of payees from database
payees = []
records = actions.get_bills()
for rec in records:
if rec.payee not in payees:
payees.append(rec.payee)
store = gtk.ListStore(gobject.TYPE_STRING)
for payee in payees:
store.append([payee])
self.payee.set_model(store)
self.payeecompletion.set_model(store)
self.payee.set_text_column(0)
self.payeecompletion.set_text_column(0)
self.payeeEntry = self.payee.child
self.selectedText = ''
def _get_payee(self):
""" Extracts information typed into comboboxentry """
if self.payee.get_active_iter() is not None:
model = self.payee.get_model()
iteration = self.payee.get_active_iter()
if iteration:
return model.get_value(iteration, 0)
else:
return self.payeeEntry.get_text()
def _populate_frequency(self):
""" Populates combobox with allowable frequency. """
store = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_INT)
self.frequency.set_model(store)
cell = gtk.CellRendererText()
self.frequency.pack_start(cell, True)
self.frequency.add_attribute(cell, 'text', 0)
for i, frequency in enumerate([scheduler.SC_ONCE,
scheduler.SC_MONTHLY,
scheduler.SC_WEEKLY]):
store.append([frequency, i])
# Set SC_ONCE as default
self.frequency.set_active(0)
self.on_frequency_changed(self.frequency)
def _populate_category(self, categoryname=None):
""" Populates combobox with existing categories """
# Connects to the database
actions = Actions()
# List of categories from database
categories = []
records = actions.get_categories()
ret = 0
empty_color = create_pixbuf()
for rec in records:
#if [rec['categoryname'], rec['id']] not in categories:
#TODO: Better put color creation in a function
color = rec.color and rec.color or '#000'
categories.append([create_pixbuf(color=color), rec.name, int(rec.id)])
if categoryname and categoryname == rec.name:
ret = len(categories) + 1
store = gtk.ListStore(gtk.gdk.Pixbuf, str, int)
self.category.set_model(store)
store.append([empty_color, _("None"), 0])
store.append([None, "---", -1])
for category in categories:
store.append(category)
store.append([None, "---", -1])
store.append([empty_color, _("New Category"), -2])
self.category.set_active(ret)
return ret
def _get_category(self):
""" Extracts information typed into comboboxentry """
actions = Actions()
if self.category.get_active_iter() is not None:
model = self.category.get_model()
iteration = self.category.get_active_iter()
if iteration:
name = model.get_value(iteration, 1)
else:
name = None
if not name or name == _("None"):
return None
records = actions.get_categories(name=name)
if records:
return records[0]
else:
return None
def get_record(self):
frequency = self.frequency.get_active_text()
# Extracts the date off the calendar widget
# Create datetime object
selectedDate = self.dueDate.get_date()
# End date
if frequency != scheduler.SC_ONCE:
endDate = self.endDate.get_date()
# Notify user that the endDate is set in the past
if endDate < selectedDate:
endDate = selectedDate
message = utils.Message()
text = _("The end date is set to a date prior to the start date. Setting it to match the start date.")
title = _("Date set in the past")
message.ShowInfo(text=text, parentWindow=self.window, title=title)
else:
endDate = None
#buffer = self.txtNotes.get_buffer()
startiter, enditer = self.txtbuffer.get_bounds()
sbuffer = self.txtbuffer.get_text(startiter, enditer)
# Gets the payee
payee = self._get_payee()
# Gets the category
category = self._get_category()
# Gets the alarm date
alarm = self.alarmbutton.get_date() or None
# Validate form
if not payee.strip():
return None
if self.amount.get_text().strip():
amount = utils.currency_to_float(self.amount.get_text())
else:
amount = None
if self.currentrecord is None:
# Verify how many bills will be inserted
# this will only work for new bills
records = []
# Figures out how many times we're repeating this bill
days = scheduler.get_schedule_date(
frequency, selectedDate, endDate)
for day in days:
if alarm:
alarm = self.__get_alarm_date(day)
rec = Bill(payee=payee, amount=amount, dueDate=day, alarmDate=alarm, notes=sbuffer, repeats=False)
# Bill repeats...
if len(days) > 1:
rec.repeats = True
# ... and has a category.
if category:
rec.category = category
records.append(rec)
return records
else:
# Edit existing bill
self.currentrecord.payee = payee
self.currentrecord.dueDate = selectedDate
self.currentrecord.amount = amount
self.currentrecord.notes = sbuffer
self.currentrecord.alarmDate = alarm
if category:
self.currentrecord.category = category
#return the bill
return [self.currentrecord]
def on_frequency_changed(self, widget):
startDate = self.dueDate.get_date()
endDate = self.endDate.get_date()
frequency = widget.get_active_text()
if frequency == scheduler.SC_ONCE:
self.endDate.set_sensitive(False)
else:
self.endDate.set_sensitive(True)
if startDate > endDate:
self.endDate.set_date(self.dueDate.get_date())
def on_edit_categories_clicked(self, button, new = False):
category = None
# if new == True, a simpler categories dialog pops up
self.window.category = self.category
categories = CategoriesDialog(parent = self.window, new = new)
ret = categories.run()
if ret == gtk.RESPONSE_OK:
#TODO: We should handle the saving in the dialog itself.
# the category hasn't been saved yet... so save it.
if new:
categories._on_savebutton_clicked(None)
category = categories.currentrecord
categories.destroy()
# Always re-populate the categories dropdown widget, regardless if
# newer category was added. If something was returned, select it.
if category:
self._populate_category(category.name)
else:
self._populate_category()
return ret
def on_category_changed(self, combobox):
index = self.category.get_active()
model = self.category.get_model()
if index == len(model) - 1:
self.category.set_active(self.category_index_before)
self.on_edit_categories_clicked(combobox, True)
self.category_index_before = index
def on_amount_insert_text(self, entry, string, len, position):
for char in string:
if char not in self.allowed_digts:
print "Invalid Character: %s" % char
entry.emit_stop_by_name("insert-text")
gtk.gdk.beep()
return
def on_save_clicked(self, widget):
message = utils.Message()
startDate = self.dueDate.get_date()
endDate = self.endDate.get_date()
if not self._get_payee().strip() and \
not self.amount.get_text().strip():
message.ShowError(_("\"%s\" and \"%s\" are required fields.") \
% (_("Payee"), _("Amount")), self.window)
self.payee.grab_focus()
elif not self._get_payee().strip():
message.ShowError(_("\"%s\" is required field.") % _("Payee"), self.window)
self.payee.grab_focus()
elif not self.amount.get_text().strip():
message.ShowError(_("\"%s\" is required field.") % _("Amount"), self.window)
self.amount.grab_focus()
elif self.endDate.get_sensitive() and startDate > endDate:
message.ShowError(_("The end date is set to a date prior to the start date."), self.window)
else:
self.window.response(gtk.RESPONSE_ACCEPT)
def _on_datepicker_date_changed(self, widget, args):
startDate = self.dueDate.get_date()
endDate = self.endDate.get_date()
if widget == self.dueDate:
if self.endDate.get_sensitive() and startDate > endDate:
# Update endDate to be equal to dueDate
self.endDate.set_date(self.dueDate.get_date())
else:
if self.endDate.get_sensitive():
if startDate > endDate:
# Update endDate to be equal to dueDate
self.endDate.set_date(self.dueDate.get_date())
if self.alarmbutton.get_date():
# Extracts the date off the datepicker widget
alarmDate = self.__get_alarm_date(self.dueDate.get_date())
self.alarmbutton.set_date(alarmDate)
def __get_alarm_date(self, date):
# Use alarm values from preferences
atime = self.gconf_client.get('show_alarm_at_time')
adays = self.gconf_client.get('show_alarm_before_days')
return scheduler.get_alarm_timestamp(adays, atime, date)
def __init__(self, settings=None):
self.settings = settings or Settings()
class Alarm(object):
def __init__(self, parent):
self.parent = parent
self.tray_hints = {}
self.parent = parent
self.tray_hints = {}
self.gconf_client = Configuration()
self.start()
def start(self):
start_delay = self.gconf_client.get('startup_delay')
print start_delay
showStartup = self.gconf_client.get('show_startup_notification')
print showStartup
if showStartup:
timeout_add(start_delay, self.show_pay_notification)
timeout_add(start_delay + 12000, self.verify_due)
interval = self.gconf_client.get('interval')
print interval
if interval:
timeout_add(interval, self.timer)
def notification(self, title, body):
notify = NotifyMessage(self.parent)
notify.title = title
notify.body = body
notify.set_timeout(20)
notify.set_default_action(self.__cb_launch_gui)
notify.hints = self.tray_hints
return notify
def show_pay_notification(self):
print "Got here 3"
today = datetime.datetime.today()
limit = self.gconf_client.get('notification_days_limit')
print limit
limit = datetime.timedelta(days=limit)
end = today + limit
if limit:
records = self.parent.actions.get_interval_bills(end=end, paid=False)
#'dueDate <= %s AND paid = 0' % (today + limit))
else:
print "No limit"
records = self.parent.actions.get_bills(paid=False)
msg = ngettext('You have %s outstanding bill to pay!',
'You have %s outstanding bills to pay!',
len(records)) % len(records)
if msg and records:
bubble = self.notification(common.APPNAME, msg)
bubble.add_action("view", _("Show BillReminder"),
self.__cb_launch_gui, None)
#bubble.add_action("close", _("Cancel"), None)
bubble.show()
return False
def verify_due(self, sum=0):
print "Got here 2"
showDueAlarm = self.gconf_client.get('show_due_alarm')
print showDueAlarm
if not showDueAlarm:
print "Do not show due alarm"
return
today = datetime.datetime.today()
if sum > 0:
records = self.parent.actions.get_interval_bills(today, today, False)
else:
records = self.parent.actions.get_interval_bills(end=today, paid=False)
i = 1
use_dialog = self.gconf_client.get('use_alert_dialog')
print use_dialog
# TODO: use only one dialog for all bills, if use_dialog == True
for bill in records:
if sum > 0:
# date format string
dtformat = locale.nl_langinfo(locale.D_FMT)
# date from record in timestamp format
dtstamp = bill.dueDate
# record dictionary
recDict = {
'bill': "<b>\"%s\"</b>" % bill.payee,
'day': "<b>\"%s\"</b>" % dtstamp.strftime(dtformat).encode('ASCII')
}
# TODO: calculate days
timeout_add(i * 12000,
self.show_bill_notification,
bill,
_("The bill %(bill)s will be due at %(day)s.") % recDict,
use_dialog)
else:
timeout_add(i * 12000,
self.show_bill_notification,
bill,
None,
use_dialog)
i += 1
def show_bill_notification(self, bill=None, msg=None, alert=False, timeout=None):
if msg is None:
msg = _('The bill %s is due.') % "<b>\"%s\"</b>" % bill.payee
if not self.parent.actions.get_bills(id=bill.id)[0].paid:
if alert:
alert = Message().ShowBillInfo(text=msg,
title=_("BillReminder Notifier"))
if alert == RESPONSE_YES:
self.__cb_mark_as_paid(None, (bill,))
elif alert == RESPONSE_NO:
self.__cb_edit_bill(None, (bill,))
else:
bubble = self.notification(common.APPNAME, msg)
bubble.add_action("paid", _("Mark as paid"),
self.__cb_mark_as_paid, bill)
bubble.add_action("edit", _("Edit"), self.__cb_edit_bill, bill)
#bubble.add_action("close", _("Cancel"), None)
if timeout:
bubble.set_timeout(timeout)
bubble.show()
return False
def __cb_launch_gui(self, *arg):
# If client is not running, launch it
# Send DBus 'show_main_window' signal
self.parent.dbus_server.show_main_window()
if not self.parent.client_pid or \
not verify_pid(self.parent.client_pid):
gui = Popen('billreminder', shell=True)
self.parent.client_pid = gui.pid
def __cb_mark_as_paid(self, *arg):
record = arg[1][0]
if record:
record.paid = True
try:
# Edit bill to database
self.parent.dbus_server.edit_bill(record)
except Exception, e:
print "Error #1"
print str(e)
def __init__(self, injected_mongo_client=None):
self.settings = Settings().getSettings()
self.forgot_password = injected_mongo_client or MongoClient(
Settings().getServiceIp('mongo')).eyeos.forgotpassword
def __init__(self, injected_proxy_ip=None, injected_api_call=None):
self.proxy_ip = injected_proxy_ip or Settings().getServiceIp('proxy')
self.api_call = injected_api_call or EyeosApiCall()
self.logger = Logger(__name__)
def __init__(self):
self.settings = Settings()
self.logger = Logger(__name__)
self.entrypoint = "proxy"
def __init__(self, settings=None):
self.settings = settings or Settings()
self.logger = Logger(__name__)
def configure(self, *, settings=None):
action = (settings
or Settings().getSettings())['logs']['warning_action']
self.warnings.filterwarnings(action)
self.warnings.formatwarning = self._format_warning
def main(args=None):
global logwriter, csvfile, ml_dict, applog, cur_state, dimcap, video_dev
global settings, hmqtt, show_windows, read_cam, read_local_resize, remote_cam
global camera_spin, camera_capture_to_file
global cap_prefix, backup_ml, have_cuda, use_three_arg
# process cmdline arguments
ap = argparse.ArgumentParser()
loglevels = ('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL')
ap.add_argument("-c", "--conf", required=True, type=str,
help="path and name of the json configuration file")
ap.add_argument("-d", "--debug", action='store', type=bool, default=False,
nargs='?', help="show rectangles - no remote ml")
ap.add_argument("-s", "--syslog", action = 'store_true',
default=False, help="use syslog")
ap.add_argument("-a", "--algorithm", required=False, type=str, default=None,
help="detection algorithm override")
ap.add_argument("-m", "--movement", required=False, type=str,
help="movement algorithm override")
ap.add_argument("-e", "--events", required=False, action = "store_true", default=False,
help="log events to events.csv file")
ap.add_argument("-r", "--remote", required=False, action = "store_true", default=False,
help="log events to file")
ap.add_argument("-p", "--port", action='store', type=int, default='4466',
nargs='?', help="server port number, 4466 is default")
ap.add_argument('-l', '--log', default='DEBUG', choices=loglevels)
#ap.add_argument("-f", "--capture", required=False, type=str,
# help="path and name for image captures")
ap.add_argument('-3', "--three_arg", action = 'store_true',
default=False, help="findContours has 3 return values")
args = vars(ap.parse_args())
# frame capture setup
#if args['capture']:
# cap_prefix = args['capture']
#else:
# cap_prefix = None
# logging setup
applog = logging.getLogger('mqttcamera')
#applog.setLevel(args['log'])
if args['syslog']:
applog.setLevel(logging.DEBUG)
handler = logging.handlers.SysLogHandler(address = '/dev/log')
# formatter for syslog (no date/time or appname. Just msg, lux, luxavg
formatter = logging.Formatter('%(name)s-%(levelname)-5s: %(message)-30s %(lux)s %(sum)s')
handler.setFormatter(formatter)
f = LuxLogFilter()
applog.addFilter(f)
applog.addHandler(handler)
else:
logging.basicConfig(level=logging.DEBUG,datefmt="%H:%M:%S",format='%(asctime)s %(message)-40s %(lux)s %(sum)s')
f = LuxLogFilter()
applog.addFilter(f)
show_windows = False;
# state_machine log file
logwriter = None
csvfile = None
if args['events']:
csvfile = open('events.csv', 'w', newline='')
logwriter = csv.writer(csvfile, delimiter=',', quotechar='|')
print("logging...")
# Lets spin it up.
settings = Settings(args["conf"],
"/var/local/etc/mqtt-camera.json",
applog,
next_state)
# cmd line args override settings file.
if args['algorithm']:
settings.ml_algo = args['algorithm']
applog.debug("cmd line algo override: %s", settings.ml_algo)
if args['movement']:
settings.mv_algo = args['movement']
applog.debug("cmd line movement override: %s", settings.mv_algo)
if args['remote']:
settings.use_ml = 'remote'
'''
if args['port']:
print('override port')
settings.ml_port = args['port']
'''
if args['debug']:
show_windows = True
settings.use_ml = 'local'
if args['three_arg']:
# yet another damn global for a bug
use_three_arg = True
hmqtt = Homie_MQTT(settings,
settings.get_active_hold,
settings.set_active_hold)
settings.display()
settings.log = applog
if logwriter:
logwriter.writerow([settings.settings_serialize])
# setup ml_dict. Dealing with the backup is a bit hackish.
# Rpc proxy's are setup the first time they are needed.
have_cuda = is_cuda_cv()
applog.info(f"Have CUDA: {check_cuda()}")
if settings.use_ml == 'local':
applog.info(f"Will use CUDA: {have_cuda}")
ml_dict = build_ml_dict(False, None, None, applog)
cur_state = State.motion_wait
dimcap = (settings.camera_width, settings.camera_height)
# Almost Done with setup. Maybe.
if settings.camera_type == 'capture':
video_dev = cv2.VideoCapture(settings.camera_number)
read_cam = capture_read_cam
read_local_resize = capture_read_local_resize
remote_cam = capture_remote_cam
camera_spin = capture_camera_spin
camera_capture_to_file = capture_camera_capture_to_file
elif settings.camera_type == 'nvidia-rtsp':
video_dev = nvidia_cam_rtsp(settings.camera_number, settings.camera_width,
settings.camera_height, 0)
read_cam = stream_read_cam
read_local_resize = stream_read_local_resize
remote_cam = stream_remote_cam
camera_spin = stream_camera_spin
camera_capture_to_file = stream_camera_capture_to_file
elif settings.camera_type == 'ffmpeg-rtsp':
os.environ["OPENCV_FFMPEG_CAPTURE_OPTIONS"] = "rtsp_transpo rt;udp"
video_dev = cv2.VideoCapture(settings.camera_number,cv2.CAP_FFMPEG)
read_cam = stream_read_cam
read_local_resize = stream_read_local_resize
remote_cam = stream_remote_cam
camera_spin = stream_camera_spin
camera_capture_to_file = stream_camera_capture_to_file
elif settings.camera_type == 'gst':
video_dev = cv2.VideoCapture(settings.camera_prep,cv2.CAP_GSTREAMER)
read_cam = stream_read_cam
read_local_resize = stream_read_local_resize
remote_cam = stream_remote_cam
camera_spin = stream_camera_spin
camera_capture_to_file = stream_camera_capture_to_file
elif settings.camera_type == 'stream':
video_dev = VideoStream(src=settings.camera_number, resolution = dimcap).start()
read_cam = imstream_read_cam
read_local_resize = imstream_read_local_resize
remote_cam = imstream_remote_cam
camera_spin = imstream_camera_spin
camera_capture_to_file = imstream_camera_capture_to_file
else:
log('bad camera_type in settings file')
exit()
# a cross coupling hack?
hmqtt.capture = camera_capture_to_file
init_timers(settings)
atexit.register(cleanup)
# now we pick between movement detectors and start the choosen one
if settings.mv_algo == 'adrian_1':
while True:
adrian_1_init()
while True:
adrian_1_movement(show_windows)
if cur_state == State.restart:
#log("restarting adrian_1 loop")
break
if show_windows and cv2.waitKey(40) == 27:
break
elif settings.mv_algo == 'intel':
while True:
intel_init()
while True:
intel_movement(show_windows, read_local_resize)
if cur_state == State.restart:
log("restarting intel loop")
breakl
else:
print("No Movement Algorithm chosen")
cleanup()
help="path and name of the json configuration file")
ap.add_argument("-d",
"--debug",
action='store',
type=int,
default='3',
nargs='?',
help="debug level, default is 3")
args = vars(ap.parse_args())
# fix debug levels
if args['debug'] == None:
debug_level = 3
else:
debug_level = args['debug']
settings = Settings(args["conf"], None, log)
hmqtt = Homie_MQTT(settings)
settings.print()
# Now we loop forever
unresp = 0
while True:
# get the ups data
status = {}
try:
with PyNUTClient() as s:
status = s.list_vars(settings.nut_ups)
except:
pass
# did we get good values?
class AmelieProgramm:
''' CLI version of AmelieBot.
This class is the programm itself.
'''
_amelie: Amelie
_dialog: Dialog
_logger: Logger
_console: Console
_settingsFile: Settings
_fileManager: FileManager
_inputMode: object
_exceptionStack: list
def __init__(self):
self._console = Console()
self._console.printLogo()
self._exceptionStack = list()
self._fileManager = FileManager()
self._logger = Logger()
self._settingsFile = Settings()
self._dialog = Dialog('en') if self._settingsFile.getLanguage(
) == '-' else Dialog(self._settingsFile.getLanguage())
#---------------------------------------------------------------------------------------------------------------#
# FILLING THE SETTINGS FILE WITH USER INPUT #
settingsMethods = self._settingsFile.getMethodsToResolveErrors()
for methodname, method in settingsMethods.items():
if methodname == "lang": # print a list of supporting languages and get user input for language setting
self._console.write(self._dialog.getMessageFor("chooseLang"))
langs = self._settingsFile.getSupportingLangs()
for key, value in langs.items():
self._console.write('[' + str(key) + ']')
self._console.write(value.upper() + ' ')
self._console.write('\n')
while (True):
langInput = int(self._console.readLine("\n--> "))
if langInput in langs.keys():
method(langs[langInput])
break
else:
self._console.writeLine(
self._dialog.getMessageFor("wrongInput"))
self._dialog.changeLanguage(self._settingsFile.getLanguage())
elif methodname == "username": # just get username fron input
while (True):
self._console.writeLine(
self._dialog.getMessageFor("getName"))
usernameInput = (self._console.readLine("\n--> "))
# checking the spelling of the username
if len(sub('[\t, \n, \r \s]', '', usernameInput)) >= 2:
method(usernameInput)
break
else:
continue
#---------------------------------------------------------------------------------------------------------------#
self._amelie = Amelie(self._settingsFile.getLanguage())
return
def __new__(cls):
if not hasattr(cls, 'instance'):
cls.instance = super(AmelieProgramm, cls).__new__(cls)
return cls.instance
return cls.instance
def restart(self) -> None:
restart()
return
def update(self):
''' Update all programm logic.
'''
if len(self._exceptionStack) > 0:
excpetion = self._exceptionStack.pop(0)
raise excpetion
self._amelie.update()
return
def writeToJournal(self, recordTitle: str, value: str) -> None:
''' Write an info-record to the journal of the program.
'''
self._logger.addRecord(recordTitle, value)
return
def changeInputMode(self, enableVoice: bool):
self._amelie.voice = enableVoice
if self._amelie.voice: self._inputMode = voiceInput
else: self._inputMode = self._console.readLine
return
def main(self):
self._console.writeLine('\n' +
self._dialog.getMessageFor("enableVoice"))
enableVoice = self._console.readLine("--> ")
while (True):
if enableVoice == "Y" or enableVoice == "y":
enableVoice = True
elif enableVoice == "N" or enableVoice == "n":
enableVoice = False
else:
self._console.writeLine(
self._dialog.getMessageFor("wrongInput"))
enableVoice = self._console.readLine("--> ")
continue
break
username = str(self._settingsFile.getUsername())
userInput = ""
if enableVoice == False:
while (True):
self._console.write('\n' + username + ": ")
userInput = self._console.readLine()
self._console.writeLine(
"\t\t\tAmelie: " +
self._amelie.conversation(enableVoice, userInput))
else:
while (True):
self._console.write('\n' + username + ": ")
chatAnswer = self._amelie.conversation(enableVoice, userInput)
self._console.write(self._amelie.getUserInput() + '\n')
self._console.writeLine("\t\t\tAmelie: " + chatAnswer + '\n')
self._console.write(self._dialog.getMessageFor("wait"))
msvcrt.getch()
return
def __del__(self):
self._amelie.__del__()
self._fileManager.__del__()
class PrefDialog(gtk.Dialog):
"""
Class used to generate dialog to allow user to edit preferences.
"""
def __init__(self, parent=None):
title = _("Preferences")
gtk.Dialog.__init__(self,
title=title,
parent=parent,
flags=gtk.DIALOG_MODAL
| gtk.DIALOG_DESTROY_WITH_PARENT
| gtk.DIALOG_NO_SEPARATOR,
buttons=(gtk.STOCK_CLOSE, gtk.RESPONSE_ACCEPT))
self.set_position(gtk.WIN_POS_CENTER)
self.set_border_width(6)
self.set_resizable(False)
self.set_icon_from_file(common.APP_ICON)
self.props.skip_taskbar_hint = True
self.gconf_client = Settings()
self._initialize_dialog_widgets()
self._populate_fields()
self._connect_fields()
self.connect("response", lambda self, *args: self.destroy())
def _initialize_dialog_widgets(self):
self.topcontainer = gtk.VBox(homogeneous=False, spacing=18)
self.topcontainer.set_border_width(6)
# Alert Group
alertFrame = gtk.VBox(homogeneous=False, spacing=6)
alertAlignment = gtk.Alignment()
alertAlignment.set_padding(0, 0, 12, 0)
title = gtk.Label()
title.set_markup(_("<b>Alarms</b>"))
title.set_alignment(0.00, 0.50)
alertFrame.pack_start(title)
alertFrame.pack_start(alertAlignment)
alertContainer = gtk.VBox(homogeneous=False, spacing=6)
self.alertCheckbox = gtk.CheckButton(_('_Alert before due date:'),
use_underline=True)
self.alertSpinButton = gtk.SpinButton()
self.alertSpinButton.set_range(0, 360)
self.alertSpinButton.spin(gtk.SPIN_STEP_FORWARD)
self.alertSpinButton.set_increments(1, 7)
alertDays = gtk.Label("%s" % _('day(s).'))
self.notificationTime = TimeWidget()
alertPreferredTime = gtk.Label()
alertPreferredTime.set_markup_with_mnemonic(_('_Preferred time:'))
alertPreferredTime.set_mnemonic_widget(
self.notificationTime.hourSpinner)
alertPreferredTime.set_alignment(0.00, 0.50)
alertDefinition = gtk.Label(
_('Get alerted when individual bills are due.'))
alertDefinition.set_alignment(0.00, 0.90)
# Add label defining what an alarm means.
alertContainer.pack_start(alertDefinition,
expand=False,
fill=True,
padding=0)
# Container for alert checkbox and spin button for day selection.
hbox = gtk.HBox(homogeneous=False, spacing=4)
hbox.pack_start(self.alertCheckbox, expand=False, fill=True, padding=0)
hbox.pack_start(self.alertSpinButton,
expand=False,
fill=False,
padding=0)
hbox.pack_start(alertDays, expand=False, fill=False, padding=0)
alertContainer.pack_start(hbox, expand=False, fill=True, padding=0)
# Container for preferred time for alerts.
hbox = gtk.HBox(homogeneous=False, spacing=12)
hbox.pack_start(alertPreferredTime, expand=False, fill=True, padding=0)
hbox.pack_start(self.notificationTime,
expand=True,
fill=True,
padding=0)
alertContainer.pack_start(hbox, expand=False, fill=True, padding=0)
alertAlignment.add(alertContainer)
# Notification Group
notifyFrame = gtk.VBox(homogeneous=False, spacing=6)
title = gtk.Label()
title.set_markup(_("<b>Notifications</b>"))
title.set_alignment(0.00, 0.50)
notifyAlignment = gtk.Alignment()
notifyAlignment.set_padding(0, 0, 12, 0)
notifyFrame.pack_start(title)
notifyFrame.pack_start(notifyAlignment)
notificationDefinition = gtk.Label(
_('Define when to be notified of upcoming bills.'))
notificationDefinition.set_alignment(0.00, 0.90)
notificationsContainer = gtk.VBox(homogeneous=False, spacing=6)
# Add label defining what a definition means.
notificationsContainer.pack_start(notificationDefinition,
expand=False,
fill=False,
padding=0)
self.notifyCheckbox = gtk.CheckButton(_('_Notify before due date:'),
use_underline=True)
self.notifySpinButton = gtk.SpinButton()
self.notifySpinButton.set_range(0, 360)
self.notifySpinButton.spin(gtk.SPIN_STEP_FORWARD)
self.notifySpinButton.set_increments(1, 7)
notifyDays = gtk.Label("%s" % _('day(s).'))
# Container for notification checkbox and spin button for day selection.
hbox = gtk.HBox(homogeneous=False, spacing=4)
hbox.pack_start(self.notifyCheckbox,
expand=False,
fill=True,
padding=0)
hbox.pack_start(self.notifySpinButton,
expand=False,
fill=False,
padding=0)
hbox.pack_start(notifyDays, expand=False, fill=False, padding=0)
notificationsContainer.pack_start(hbox,
expand=False,
fill=True,
padding=0)
notifyAlignment.add(notificationsContainer)
# Alert Type Group
alertTypeFrame = gtk.VBox(homogeneous=False, spacing=6)
title = gtk.Label()
title.set_markup(_("<b>Alert Type</b>"))
title.set_alignment(0.00, 0.50)
alertTypeAlignment = gtk.Alignment()
alertTypeAlignment.set_padding(0, 0, 12, 0)
alertTypeFrame.pack_start(title)
alertTypeFrame.pack_start(alertTypeAlignment)
vbox = gtk.VBox(homogeneous=False, spacing=6)
hbox = gtk.HBox(homogeneous=False, spacing=12)
self.alertBubble = gtk.RadioButton(label=_("Notification _Bubble"))
self.alertDialog = gtk.RadioButton(group=self.alertBubble,
label=_("Alert _Dialog"))
hbox.pack_start(self.alertBubble, expand=False, fill=False, padding=0)
hbox.pack_start(self.alertDialog, expand=False, fill=False, padding=0)
vbox.pack_start(hbox, expand=False, fill=False, padding=0)
alertTypeAlignment.add(vbox)
# Daemon Warning
daemonContainer = gtk.VBox(homogeneous=False, spacing=6)
self.daemonLabel = gtk.Label(
_("<b>Warning:</b> BillReminder Notifier is \n" \
"not running! You need to start it in order \n" \
" to receive notifications."))
self.daemonLabel.set_justify(gtk.JUSTIFY_CENTER)
self.daemonLabel.set_use_markup(True)
daemonImage = gtk.Image()
daemonImage.set_from_stock('gtk-execute', 2)
self.daemonButton = gtk.Button(label=_("_Start BillReminder Notifier"))
self.daemonButton.set_relief(gtk.RELIEF_NONE)
self.daemonButton.set_image(daemonImage)
daemonContainer.pack_start(self.daemonLabel,
expand=False,
fill=True,
padding=0)
daemonContainer.pack_start(self.daemonButton,
expand=False,
fill=True,
padding=0)
# Everything
self.topcontainer.pack_start(alertFrame,
expand=False,
fill=True,
padding=0)
self.topcontainer.pack_start(notifyFrame,
expand=False,
fill=True,
padding=0)
self.topcontainer.pack_start(alertTypeFrame,
expand=False,
fill=True,
padding=0)
if not utils.verify_dbus_service(common.DBUS_INTERFACE):
self.topcontainer.pack_start(daemonContainer,
expand=False,
fill=True,
padding=0)
self.vbox.pack_start(self.topcontainer, expand=False, fill=True)
self.show_all()
def _populate_fields(self):
self.notifyCheckbox.set_active(
self.gconf_client.get('show_before_alarm'))
self.alertCheckbox.set_active(self.gconf_client.get('show_alarm'))
if not self.gconf_client.get('use_alert_dialog'):
self.alertBubble.set_active(True)
else:
self.alertDialog.set_active(True)
# Number of days before showing alarm
adays = self.gconf_client.get('notification_days_limit')
self.notifySpinButton.set_value(adays and adays or 3)
self.alertSpinButton.set_value(
self.gconf_client.get('show_alarm_before_days'))
atime = self.gconf_client.get('show_alarm_at_time')
atime = atime.split(":")
self.notificationTime.setHourMinute(atime[0], atime[1])
def _connect_fields(self):
self.notificationTime.hourSpinner.connect("value_changed",
self._on_time_changed)
self.notificationTime.minuteSpinner.connect("value_changed",
self._on_time_changed)
self.notifyCheckbox.connect("toggled", self._on_checkbox_toggled,
'show_before_alarm')
self.alertCheckbox.connect("toggled", self._on_checkbox_toggled,
'show_alarm')
self.notifySpinButton.connect("changed", self._on_spin_changed,
'notification_days_limit')
self.alertSpinButton.connect("changed", self._on_spin_changed,
'show_alarm_before_days')
self.alertDialog.connect("toggled", self._on_checkbox_toggled,
'use_alert_dialog')
self.daemonButton.connect("clicked", self._launch_daemon)
def _on_time_changed(self, spin):
alarm = self.notificationTime.getTime()
alarm = ":".join(["%.02d" % x for x in alarm])
self.gconf_client.set('show_alarm_at_time', alarm)
def _on_checkbox_toggled(self, togglebutton, item):
self.gconf_client.set(item, togglebutton.get_active())
def _on_spin_changed(self, obj, item):
self.gconf_client.set(item, int(obj.get_value()))
def _launch_daemon(self, button):
Popen('billreminderd', shell=True)
button.hide()
self.daemonLabel.set_markup(
_("<b>Note:</b> BillReminder Notifier is now running."))
class MainDialog(gobject.GObject):
search_text = ""
_bullet_cache = {}
__gsignals__ = {
"bill-added": (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,)),
"bill-updated": (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,)),
"bill-removed": (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,)),
}
def __init__(self):
gobject.GObject.__init__(self)
if exists(join(USER_CFG_PATH, CFG_NAME)):
from lib.migrate_to_gconf import migrate
migrate(join(USER_CFG_PATH, CFG_NAME))
self.gconf_client = Configuration()
self.message = Message()
# Connects to the database
self.actions = Actions()
self.ui = gtk.Builder()
self.ui.add_from_file(os.path.join(DEFAULT_CFG_PATH, "main.ui"))
self.window = self.ui.get_object("main_window")
self.window.set_title("%s" % common.APPNAME)
self.window.set_icon_from_file(common.APP_ICON)
# ViewBill
self.list = ViewBill()
self.list.connect("cursor_changed", self._on_list_cursor_changed)
self.list.connect("row_activated", self._on_list_row_activated)
self.list.connect("button_press_event", self._on_list_button_press_event)
self.ui.get_object("bill_box").add(self.list)
# Toolbar
self.toolbar = self.ui.get_object("toolbar")
# Menubar
self._populate_menubar()
# Statusbar
self.statusbar = Statusbar()
self.ui.get_object("statusbar_box").add(self.statusbar)
# Restore timeline zoom
timeline_count = self.gconf_client.get("timeline_count")
# Timeline
self.timeline = Timeline(count=timeline_count, callback=self.on_timeline_cb)
self.timeline.connect("range-changed", self._on_timeline_changed)
self.timeline.connect("button-press-event", self._on_timeline_click)
self.timeline.connect("cleared", self._on_timeline_cleared)
self.ui.get_object("timeline_box").add(self.timeline)
# Chart
self.chart = ChartWidget()
self.chart.set_border_width(10)
self.ui.get_object("chart_box").add(self.chart)
# Restore position and size of window
width = self.gconf_client.get("window_width")
height = self.gconf_client.get("window_height")
x = self.gconf_client.get("window_position_x")
y = self.gconf_client.get("window_position_y")
if width and height:
self.window.resize(width, height)
if x and y:
self.window.move(x, y)
self.window.show_all()
# Whether to display toolbar or not
self.on_showToolbar_toggled(self.ui.get_object("showToolbar"))
self.list.grab_focus()
if self.gconf_client.get("start_in_tray"):
self.window.hide()
self.toggle_buttons()
# Connects to the Daemon
self.iface = None
iface = get_dbus_interface(common.DBUS_INTERFACE, common.DBUS_PATH)
if iface:
iface.connect_to_signal("bill_edited", self.reloadTreeView)
iface.connect_to_signal("bill_edited", self.reloadTimeline)
iface.connect_to_signal("show_main_window", self.window.show)
self.iface = iface
gobject.timeout_add(2000, self._send_tray_hints)
self.set_action_strings()
self.ui.connect_signals(self)
# populate treeview
self.reloadTreeView()
self.notify = NotifyIcon(self)
# Integrate with Ubuntu Unity
if UNITY:
self.unity = UnityIntegration(self)
def set_action_strings(self):
# for some reason the actions strings do not get translated yet
# so we define them here so they would be picked up by the pyfile scanner
self.ui.get_object("newBill").set_label(_("_New"))
self.ui.get_object("newBill").set_tooltip(_("Add new bill"))
self.ui.get_object("editBill").set_label(_("_Edit"))
self.ui.get_object("editBill").set_tooltip(_("Edit a bill"))
self.ui.get_object("removeBill").set_label(_("_Delete"))
self.ui.get_object("removeBill").set_tooltip(_("Delete selected bill"))
self.ui.get_object("markPaid").set_label(_("P_aid"))
self.ui.get_object("markPaid").set_tooltip(_("Mark as paid"))
self.ui.get_object("markNotPaid").set_label(_("No_t Paid"))
self.ui.get_object("markNotPaid").set_tooltip(_("Mark as not paid"))
self.ui.get_object("showToolbar").set_label(_("_Show Toolbar"))
self.ui.get_object("showToolbar").set_tooltip(_("Show the toolbar"))
# Methods: UI
def _send_tray_hints(self):
self.iface.set_tray_hints(force_string(self.notify.get_hints()))
gobject.timeout_add(60000, self._send_tray_hints)
def get_window_visibility(self):
return self.window.get_property("visible")
def show_hide_window(self):
if self.window.get_property("visible"):
self.window.hide()
else:
self.window.show()
def get_selected_record(self):
""" Returns a bill object from the current selected record """
if len(self.list.listStore) > 0:
model_ = self.list.get_model()
if self.list.get_cursor()[0]:
index = self.list.get_cursor()[0][0]
else:
index = 0
b_id = model_[index][0]
records = self.actions.get_bills(id=b_id)
self.currentrecord = records[0]
else:
self.currentrecord = None
print "Current record is: %s" % self.currentrecord
def populate_view(self, records):
""" Populates the treeview control with the records passed """
# Reset list
self.list.listStore.clear()
if not records:
return 0
# Loops through bills collection
path = 0
for rec in records:
# Format the record prior to adding it to treeview
row = self.format_row(rec)
self.list.add(row)
# Set the cursor to the first (top) record
self.list.set_cursor(path)
# Returns how many records there are in the treeview
return len(records)
def reloadTreeView(self, *arg):
# Update list with updated record
status = self.gconf_client.get("show_paid_bills")
path = self.list.get_cursor()[0]
self.list.listStore.clear()
self.currentrecord = None
first = self.timeline.start_date
last = self.timeline.end_date
# Get list of records
records = self.actions.get_interval_bills(first, last, status)
# Populate treeview
self.populate_view(records)
# Update status bar
self.update_statusbar()
# populate chart
self._populate_chart(status, first, last)
return len(records)
def format_row(self, row):
""" Formats a bill to be displayed as a row. """
categoryName = row.category.name if row.category else _("None")
categoryColor = row.category.color if row.category else "#d3d7cf"
formatted = [
row.id,
create_pixbuf(color=categoryColor),
categoryName,
row.payee,
row.dueDate.strftime(_("%m/%d").encode("ASCII")),
row.amount,
row.notes,
int(row.paid),
None,
]
return formatted
def _populate_chart(self, status, start, end):
records = []
categories = []
totals = []
records = self.actions.get_monthly_totals(start, end, status)
# Chart widget takes data in format (('CategoryName', amount),)
categories = [cat or "None" for cat, total in records]
totals = [float(total) for cat, total in records]
# records = [(c if c else 'None',float(t)) for c,t in records]
# set bar colors
all_categories = self.actions.get_categories()
self.chart.chart.key_colors = dict([(cat.name or "None", cat.color) for cat in all_categories])
self.chart.plot(categories, totals)
def _populate_menubar(self):
try:
saved_view = self.gconf_client.get("show_paid_bills")
except:
saved_view = 1
self.gconf_client.set("show_paid_bills", saved_view)
if saved_view == 0:
self.ui.get_object("showNotPaid").set_active(True)
elif saved_view == 1:
self.ui.get_object("showPaid").set_active(True)
else:
self.ui.get_object("showAll").set_active(True)
# Check whether we display the toolbar or not
self.ui.get_object("showToolbar").set_active(self.gconf_client.get("show_toolbar"))
def add_bill(self):
selectedDate = self.timeline.value
records = dialogs.add_dialog(parent=self.window, selectedDate=selectedDate)
# Checks if the user did not cancel the action
if records:
# Add new bill to database
for rec in records:
bill_id = self.actions.add(rec)
bill = self.actions.get_bills(id=bill_id)[0]
if bill:
self.list.add(self.format_row(bill))
self.update_statusbar()
# Reload records tree (something changed)
self.reloadTreeView()
self.reloadTimeline()
def edit_bill(self):
records = dialogs.edit_dialog(parent=self.window, record=self.currentrecord)
# Checks if the user did not cancel the action
if records:
for rec in records:
# Edit bill to database
rec = self.actions.edit(rec)
self.emit("bill-updated", rec)
# Reload records tree (something changed)
self.reloadTreeView()
self.reloadTimeline()
def remove_bill(self):
self.actions.delete(self.currentrecord)
self.list.remove()
self.emit("bill-removed", None)
self.update_statusbar()
self.reloadTreeView()
self.reloadTimeline()
def toggle_bill_paid(self):
# Fetch record from database
record = self.actions.get_bills(id=self.currentrecord.id)[0]
# Toggle paid field
record.paid = False if record.paid else True
# Edit bill in the database
transaction = self.actions.add(record)
self.emit("bill-updated", record)
# Update our current copy
self.currentrecord = self.actions.get_bills(id=self.currentrecord.id)[0]
# Update timeline widget to reflect change
self._bullet_cache[self.currentrecord.dueDate] = [self.currentrecord]
# Update list with updated record
idx = self.list.get_cursor()[0][0]
self.update_statusbar(idx)
self.reloadTreeView()
self.reloadTimeline()
def about(self):
dialogs.about_dialog(parent=self.window)
def preferences(self):
dialogs.preferences_dialog(parent=self.window)
# Methods
def _quit_application(self):
self.save_position()
self.save_size()
self.save_timeline_zoom()
gtk.main_quit()
return False
def save_position(self):
x, y = self.window.get_position()
self.gconf_client.set("window_position_x", x)
self.gconf_client.set("window_position_y", y)
def save_size(self):
width, height = self.window.get_size()
self.gconf_client.set("window_width", width)
self.gconf_client.set("window_height", height)
def save_timeline_zoom(self):
count = self.timeline.count
self.gconf_client.set("timeline_count", count)
def toggle_buttons(self, paid=None):
""" Toggles all buttons conform number of records present and
their state """
for widget in ["editBill", "removeBill", "markPaid", "markNotPaid"]:
self.ui.get_object(widget).set_sensitive(len(self.list.listStore) > 0)
if len(self.list.listStore) > 0:
self.ui.get_object("markPaid").set_sensitive(paid == False)
self.ui.get_object("markNotPaid").set_sensitive(paid == True)
def update_statusbar(self, index=0):
""" This function is used to update status bar informations
about the list """
records = len(self.list.listStore)
# Record count
self.statusbar.Records(records)
if self.currentrecord:
# Display the status
self.statusbar.Notes(self.currentrecord.notes)
# Toggles toolbar buttons on/off
self.toggle_buttons(self.currentrecord.paid)
else:
# Clear the status for the selected row
self.statusbar.Notes("")
# Toggles toolbar buttons on/off
self.toggle_buttons()
show_paid_bills = self.gconf_client.get("show_paid_bills")
if show_paid_bills is 0:
self.statusbar.Info(_("Not Paid Only"))
elif show_paid_bills is 1:
self.statusbar.Info(_("Paid Only"))
else:
self.statusbar.Info("")
# Event handlers
def _on_list_button_press_event(self, widget, event):
""" This function will handle the signal to show a popup menu
sent by a right click on tvBill widget. """
if event.button == 3 and event.type == gtk.gdk.BUTTON_PRESS:
self.get_selected_record()
c = self.ui.get_object("context_menu")
c.popup(None, None, None, event.button, event.get_time())
def _on_list_row_activated(self, widget, path, column):
self._on_list_cursor_changed(widget)
self.on_editBill_activate(None)
def _on_list_cursor_changed(self, widget):
# Get currently selected bill
self.get_selected_record()
# Update statusbar
self.update_statusbar()
def on_newBill_activate(self, toolbutton):
self.add_bill()
def on_editBill_activate(self, toolbutton):
if self.currentrecord:
self.edit_bill()
def on_removeBill_activate(self, toolbutton):
if self.currentrecord:
resp = self.message.ShowQuestionYesNo(
_('Do you really want to delete "%s"?') % self.currentrecord.payee, self.window, _("Confirmation")
)
if resp:
self.remove_bill()
def on_markNotPaid_activate(self, toolbutton):
self.on_markPaid_activate(toolbutton) # forward
def on_markPaid_activate(self, toolbutton):
if self.currentrecord:
self.toggle_bill_paid()
def on_btnAbout_activate(self, toolbutton):
self.about()
def on_btnPrefs_activate(self, toolbutton):
self.preferences()
def on_btnQuit_activate(self, toolbutton):
self._quit_application()
def on_delete_event(self, widget, event, data=None):
self._quit_application()
def _on_timeline_changed(self, widget, args):
self.reloadTreeView()
def _on_timeline_cleared(self, widget, args):
self._bullet_cache = {}
def _on_timeline_click(self, widget, event):
if event.button == 1 and event.type == gtk.gdk._2BUTTON_PRESS:
self.add_bill()
def switch_view(self, view_number):
self.gconf_client.set("show_paid_bills", view_number)
self.reloadTreeView()
self.reloadTimeline()
def on_showNotPaid_toggled(self, action):
if action.get_active():
self.switch_view(0)
def on_showPaid_toggled(self, action):
if action.get_active():
self.switch_view(1)
def on_showAll_toggled(self, action):
if action.get_active():
self.switch_view(2)
def on_showToolbar_toggled(self, action):
# Toggle toolbar's visibility
if action.get_active():
self.toolbar.show_all()
else:
self.toolbar.hide_all()
self.gconf_client.set("show_toolbar", action.get_active())
def reloadTimeline(self, *args):
self._bullet_cache = {}
self.timeline.refresh()
def on_timeline_cb(self, date, display_type, force=False):
# TODO: Improve tooltip
# TODO: Improve cache
if date in self._bullet_cache.keys() and not force:
return None
self._bullet_cache[date] = self.actions.get_bills(dueDate=date)
if self._bullet_cache[date]:
status = self.gconf_client.get("show_paid_bills")
amount = 0
amount_not_paid = 0
tooltip = ""
bullet = Event()
bullet.date = date
for bill in self._bullet_cache[date]:
amount += bill.amount
if tooltip:
tooltip += "\n"
tooltip += bill.payee + " (" + str(float_to_currency(bill.amount)) + ")"
if bill.paid:
tooltip += " [%s]" % _("Paid")
if status == 0:
return False
bullet.status = bullet.status | bullet.PAID
else:
amount_not_paid += bill.amount
if date <= datetime.date.today():
if status == 1:
return False
bullet.status = bullet.status | bullet.OVERDUE
else:
if status == 1:
return False
bullet.status = bullet.status | bullet.TO_BE_PAID
if bill.notes:
tooltip += " - " + bill.notes
bullet.amountdue = amount_not_paid if amount_not_paid else amount
bullet.payee = bill.payee
bills = len(self._bullet_cache[date])
if bills > 1:
bullet.multi = bills
bullet.payee = "%d bills" % bills
bullet.tooltip = tooltip
return bullet
return None
def __init__(self, injectedSettings=None, injectedSubprocess=None):
self.logger = Logger(__name__)
self.settings = injectedSettings or Settings().getSettings()
self.subprocess = injectedSubprocess or subprocess
def main():
global settings, hmqtt, applog, turrets, tur_locks
# process cmdline arguments
loglevels = ('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL')
ap = argparse.ArgumentParser()
ap.add_argument("-c", "--conf", required=True, type=str,
help="path and name of the json configuration file")
ap.add_argument("-s", "--syslog", action = 'store_true',
default=False, help="use syslog")
ap.add_argument("-d", "--debug", action='store', type=int, default='3',
nargs='?', help="debug level, default is 3")
args = vars(ap.parse_args())
# logging setup
applog = logging.getLogger('mqttlaser')
#applog.setLevel(args['log'])
if args['syslog']:
applog.setLevel(logging.DEBUG)
handler = logging.handlers.SysLogHandler(address = '/dev/log')
# formatter for syslog (no date/time or appname. Just msg.
formatter = logging.Formatter('%(name)s-%(levelname)-5s: %(message)-40s')
handler.setFormatter(formatter)
applog.addHandler(handler)
else:
logging.basicConfig(level=logging.DEBUG,datefmt="%H:%M:%S",format='%(asctime)s %(levelname)-5s %(message)-40s')
#GPIO.setmode(GPIO.BOARD)
settings = Settings(args["conf"],
applog)
# init turrets from settings. Do any of the turret
# use PCA9685, if so, we init that device here.
init_pca = False
kit = None
for t in settings.turrets:
if t.get('laser_pin', False):
init_pca = True
if init_pca:
applog.info('initializing PCA9685')
kit = ServoKit(channels=16)
# init mqtt server connection
hmqtt = Homie_MQTT(settings, turretCB)
for i in range(0, len(settings.turrets)):
turrets.append(Turret(settings.turrets[i], kit, applog))
tur_locks.append(Lock())
settings.print()
# fix debug levels
if args['debug'] == None:
debug_level = 3
else:
debug_level = args['debug']
atexit.register(cleanup)
# All we do now is loop over a 5 minute delay
# and let the threads work.
while True:
time.sleep(5 * 60)