def osmcprefs(whodat, key=None, value=None, *args):
db = DBInterface()
whodat = whodat.lower()
if whodat.endswith('osmc_getprefs'):
if key is None:
return '\n'.join(_get_all_settings(db=db))
else:
return str(_get_setting(key, db=db))
elif whodat.endswith('osmc_setprefs'):
if key is None or value is None:
return 'Error, no params provided\Example: osmc_setprefs key value'
else:
if value.lower() in ['true', 'false']:
db.setsetting(key, bool(value), bool)
else:
try:
db.setsetting(key, int(value), int)
except ValueError:
try:
db.setsetting(key, float(value), float)
except ValueError:
try:
db.setsetting(key, value)
except: # pragma: no cover
return 'Failed to set value'
return 'Set "%s" to "%s"' % (key, value)
def __init__(self, log_path, **kwargs):
super(LogManager, self).__init__(**kwargs)
self.log_path = log_path
self.log_interface = log_interface = DBInterface(log_path,
'log',
do_date=True,
do_hour=True)
touch_id = log_interface.get_entry('touches', 'last_touch_id', 'value')
if touch_id is None:
touch_id = 0
self.touch_id = touch_id
def __init__(self, **kwargs):
global_idmap.update({'kivysurvey': self})
self.db_interface = DBInterface(self)
super(KivySurvey, self).__init__(**kwargs)
self.transition = SlideTransition()
json = JsonStore(construct_target_file_name('survey.json', __file__))
for each in json:
print(each)
self.survey = Survey(json)
try:
gps.configure(on_location=self.receive_gps)
except:
pass
Clock.schedule_once(self.start_gps)
def __init__(self, folders_to_track, start_sync_at, pyfile, **kwargs):
super(DriveMainThread, self).__init__(**kwargs)
self.drive_data = DBInterface(
os.path.dirname(os.path.abspath(pyfile)) + '/drive_data/',
'drive_files')
base_path = os.path.dirname(os.path.abspath(pyfile)) + '/'
self.updated_folders = set()
self.start_sync_at = start_sync_at
self.folders_to_track = folders_to_track
self.setup_drive()
self.update_queue = Queue.Queue()
self.get_tracked_folder_ids(
folders_to_track,
os.path.dirname(os.path.abspath(pyfile)) + '/')
self.tracked_widgets = {}
self.folders_to_track = [
base_path + path + '/' for path in folders_to_track
]
def __init__(self, **kwargs):
self.files_being_tracked = {}
self.pyfile = pyfile = kwargs.get('pyfile', __file__)
self.drive_data = DBInterface(
os.path.dirname(os.path.abspath(pyfile)) + '/drive_data/',
'drive_files')
super(DriveCarousel, self).__init__(**kwargs)
folders_to_track = kwargs.get('folders_to_track',
self.folders_to_track)
self.set_folders_to_track(folders_to_track)
self.folder_observers = {}
self.popup = popup = Popup()
self.progress_tracker = progress_tracker = DriveProgressTracker()
#Clock.schedule_interval(self.retrieve_all_changes, 30.)
#Clock.schedule_interval(self.notify_folder_observers, 15.)
self.schedule_change(0.)
Clock.schedule_interval(self.update_carousel, 5.)
Clock.schedule_interval(self.schedule_change, 30.)
def __init__(self, **kwargs):
self.theme_manager = ThemeManager()
self.setup_font_ramps()
self.get_color = get_rgba_color
self.get_icon = get_icon_char
self.get_style = get_style
self.get_ramp_group = get_font_ramp_group
super(FlatApp, self).__init__(**kwargs)
self.setup_themes()
self.numpads = numpads = {}
numpads['decimal'] = DecimalNumPad()
numpads['regular'] = NumPad()
if self.do_device_id:
log_behavior = LogBehavior()
self.log_manager = log_manager = log_behavior.log_manager
self.settings_interface = settings_interface = DBInterface(
construct_target_file_name('', __file__), 'settings')
self.device_id = device_id = settings_interface.get_entry(
'settings', 'device_id', 'value')
self.bind(device_id=log_manager.setter('device_id'))
if device_id is None:
Clock.schedule_once(self.register_device_id)
def __init__(self, server_address, logger=None): # Member variables self.running = True self.server_address = server_address self.db = DBInterface() self.logger = logger or logging.getLogger(__name__)
# -*- coding:utf-8 -*-
import re
import csv
import datetime
import jwt
from io import StringIO
from flask import Flask, jsonify, url_for, make_response, abort, request
from werkzeug.security import generate_password_hash, check_password_hash
from dbinterface import DBInterface
from utils import API_ROUTE, API_USERS_ROUTE, API_USERS_PORT, SECRET_KEY, token_required
api = Flask(__name__)
api.config['SECRET_KEY'] = SECRET_KEY
users = DBInterface('users', ['username', 'password', 'status', 'admin'])
# Funções auxiliares
def make_public_user(user):
'''
Altera a forma de exibição de um elemento do cadastro.
Ao invés de mostrar o ID do elemento, mostra a URI do mesmo,
tornando assim mais fácil a requisição do mesmo via API.
'''
new_user = {}
for field in user:
if field == 'id':
new_user['uri'] = url_for('get_user',
user_id=user['id'],
# -*- coding:utf-8 -*-
import re
import csv
from io import StringIO
from flask import Flask, jsonify, url_for, make_response, abort, request
from werkzeug.utils import secure_filename
from dbinterface import DBInterface
from utils import API_MEDICINES_ROUTE, API_MEDICINES_PORT, token_required
api = Flask(__name__)
medicines = DBInterface(
'medicines', ['name', 'type', 'dosage', 'price', 'manufacturer', 'sales'])
# Funções auxiliares
def make_public_medicine(medicine):
'''
Altera a forma de exibição de um elemento do cadastro.
Ao invés de mostrar o ID do elemento, mostra a URI do mesmo,
tornando assim mais fácil a requisição do mesmo via API.
'''
new_medicine = {}
for field in medicine:
if field == 'id':
new_medicine['uri'] = url_for('get_medicine',
medicine_id=medicine['id'],
_external=True)
# -*- coding:utf-8 -*-
from flask import Flask, jsonify, url_for, make_response, abort, request
from dbinterface import DBInterface
from utils import API_CLIENTS_ROUTE, API_CLIENTS_PORT, token_required
api = Flask(__name__)
clients = DBInterface('clients', ['name', 'phonenumber', 'medicines'])
# Funções auxiliares
def make_public_client(client):
'''
Altera a forma de exibição de um elemento do cadastro.
Ao invés de mostrar o ID do elemento, mostra a URI do mesmo,
tornando assim mais fácil a requisição do mesmo via API.
'''
new_client = {}
for field in client:
if field == 'id':
new_client['uri'] = url_for('get_client',
client_id=client['id'],
_external=True)
else:
new_client[field] = client[field]
return new_client
def start(self):
self.logger.info('Starting NFCInterface ...')
self.db = DBInterface(self.logger)
self.running = True
while (self.running):
# Block waiting for a swipe
uuid = self.get_uuid()
# What we really want here is a callback interface, to abstract away the
# specifics of this particular project. For now, we make it work.
if (self.writing):
# If we're in writing mode
self.logger.info('In writing mode')
success = 1
# Populate the database with the UUID, if it's not already available,
# so at least this card is registered.
card_id = self.db.register_card(uuid)
if card_id is None:
success = 0
# Authenticate for reading/writing
self.mifare_auth(uuid, 0x04)
ids = [
self.write_data[0], card_id, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0
]
self.mifare_write(0x04, ids)
self.mifare_auth(uuid, 0x05)
md5hash = self.write_data[2:]
self.mifare_write(0x05, md5hash)
#binprint.print_r_t(self.write_data, "Data to be written")
# Need a check here to determine if the card has written correctly,
# then we can trust the success check below.
if (success):
self.db.update_card(card_id, self.write_data[0])
self.writing = False
self.logger.info('Success beep.')
self.red(0)
self.blink(15, 3, 0)
else:
self.logger.info("Failure beep.")
self.green(0)
self.blink(12, 3, 0)
else:
# If we're not in writing mode, we're in default reading mode
self.mifare_auth(uuid, 0x04)
response_A = self.mifare_read(0x04)
self.mifare_auth(uuid, 0x04)
response_B = self.mifare_read(0x05)
user_id = self.db.check_hash(uuid, response_A, response_B)
if (user_id):
logged_in = self.db.toggle_status(user_id) # 1 in, 0 out
if (logged_in):
self.logger.info("Success in beep.")
self.green(1)
else:
self.logger.info("Success out beep.")
self.blink(15, 2, 1)
else:
self.logger.info("Failure beep.")
self.red(1)
sleep(0.5)
self.logger.info("LED reset")
self.green(0)
self.red(0)
# Delay the loop reset for a bit of time
# to prevent someone from leaning on the
# login/logout button.
sleep(3)
