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, **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, 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)
class KivySurvey(ScreenManager):
current_page = ObjectProperty(None, allownone=True)
current_subjects = ListProperty(None, allownone=True)
db_interface = ObjectProperty(None)
current_subjects = ListProperty(None, allownone=True)
subject_id = NumericProperty(None, allownone=True)
previous_subject_ids = ListProperty(None, allownone=True)
current_page = ObjectProperty(None, allownone=True)
current_subjects_page = ObjectProperty(None, allownone=True)
next_page = StringProperty(None, allownone=True)
prev_page = StringProperty(None, allownone=True)
survey = ObjectProperty(None)
current_location = DictProperty({})
gps_loc_interval = NumericProperty(30.0)
questionnaire = StringProperty(None, allownone=True)
top_level_questionnaire = StringProperty(None, allownone=True)
root = ObjectProperty(None)
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 on_subject_id(self, instance, value):
self.load_subjects(value, self.questionnaire)
def create_subject(self):
db_interface = self.db_interface
uid = db_interface.get_unique_id()
prev_id = self.previous_subject_ids[-1]
db_interface.add_subject(prev_id, self.questionnaire, uid)
return uid
def pop_subjects(self):
previous_subject_ids = self.previous_subject_ids
if len(previous_subject_ids) > 0:
self.subject_id = self.previous_subject_ids.pop()
else:
self.subject_id = None
def on_questionnaire(self, instance, value):
self.load_subjects(self.subject_id, value)
self.current_subjects_page.allow_add_subject = (
self.survey.get_allow_add_subjects(value))
def load_subjects(self, subject_id, questionnaire):
self.current_subjects = self.db_interface.get_subjects(
subject_id, questionnaire)
def get_header_lines(self):
return self.survey.get_header_definitions(self.questionnaire)
def set_next_page(self):
survey = self.survey
next_page = survey.get_next_page(self.questionnaire,
self.current_page.page)
if next_page is None:
return False
else:
self.next_page = None
self.next_page = next_page
return True
def add_member(self):
self.transition.direction = 'left'
self.previous_subject_ids.append(self.subject_id)
self.subject_id = None
self.reset_questionnaire()
def open_member(self, member_id, instance):
self.transition.direction = 'left'
self.previous_subject_ids.append(self.subject_id)
self.subject_id = member_id
self.reset_questionnaire()
current_page = self.current_page.ids.questions
current_page.load_page_data()
def reset_questionnaire(self):
self.current_page.page = None
self.set_next_page()
self.swap_pages()
self.current_page.ids.questions.clear_questions()
def set_prev_page(self):
survey = self.survey
prev_page = survey.get_prev_page(self.questionnaire,
self.current_page.page)
if prev_page is None:
return False
else:
self.prev_page = prev_page
return True
def swap_subjects(self):
subjects1 = self.ids.subjects1
subjects2 = self.ids.subjects2
current_subjects_page = self.current_subjects_page
if current_subjects_page is subjects1:
self.current = 'subjects2'
self.current_subjects_page = subjects2
elif current_subjects_page is subjects2:
self.current = 'subjects1'
self.current_subjects_page = subjects1
self.current_subjects_page.allow_add_subject = (
self.survey.get_allow_add_subjects(self.questionnaire))
self.current_page.ids.scrollview.scroll_to_top()
def swap_pages(self):
questions1 = self.ids.questions1
questions2 = self.ids.questions2
current_page = self.current_page
if current_page is questions1:
self.current = 'questions2'
self.current_page = questions2
questions1.page = None
elif current_page is questions2:
self.current = 'questions1'
self.current_page = questions1
questions2.page = None
self.current_page.ids.scrollview.scroll_to_top()
def on_next_page(self, instance, value):
questions1 = self.ids.questions1
questions2 = self.ids.questions2
current_page = self.current_page
if current_page is questions1:
questions2.page = value
elif current_page is questions2:
questions1.page = value
def on_prev_page(self, instance, value):
questions1 = self.ids.questions1
questions2 = self.ids.questions2
current_page = self.current_page
if current_page is questions1:
questions2.page = value
elif current_page is questions2:
questions1.page = value
def start_questionnaire(self, questionnaire):
self.current_page.page = None
self.swap_subjects()
self.questionnaire = questionnaire
self.set_next_page()
def save_page(self):
current_page = self.current_page.ids.questions
current_page.save_page_data()
def go_back(self):
does_page_exist = self.set_prev_page()
survey = self.survey
questionnaire = self.questionnaire
prev_questionnaire = survey.get_previous_questionnaire()
self.transition.direction = 'right'
if self.current in ['subjects1', 'subjects2']:
if prev_questionnaire is None:
self.app.root.change_screen('cluster', go_back=True)
return
else:
if survey.get_allow_add_subjects(questionnaire):
self.pop_subjects()
self.start_questionnaire(survey.pop_previous_questionnaire())
elif does_page_exist:
self.swap_pages()
else:
if self.subject_id is None:
self.pop_subjects()
self.swap_subjects()
else:
self.pop_subjects()
self.swap_subjects()
def go_forward(self):
does_page_exist = self.set_next_page()
survey = self.survey
questionnaire = self.questionnaire
next_questionnaire = survey.get_next_questionnaire(questionnaire)
self.transition.direction = 'left'
if self.current in ['subjects1', 'subjects2']:
if next_questionnaire is None:
if survey.get_allow_add_subjects(questionnaire):
self.pop_subjects()
prev_questionnaire = survey.pop_previous_questionnaire()
self.start_questionnaire(prev_questionnaire)
else:
if survey.get_allow_forward(questionnaire):
survey.store_current_questionnaire(questionnaire)
self.start_questionnaire(next_questionnaire)
elif does_page_exist:
self.save_page()
self.swap_pages()
else:
is_creating_subject = False
if survey.get_allow_add_subjects(questionnaire) and (
self.subject_id is None):
self.subject_id = self.create_subject()
self.save_page()
if next_questionnaire is None:
self.pop_subjects()
prev_questionnaire = survey.pop_previous_questionnaire()
self.start_questionnaire(prev_questionnaire)
elif survey.get_allow_add_subjects(next_questionnaire):
survey.store_current_questionnaire(questionnaire)
self.start_questionnaire(next_questionnaire)
else:
self.pop_subjects()
self.swap_subjects()
def start_gps(self, dt):
try:
gps.start()
except:
pass
def receive_gps(self, **kwargs):
if kwargs is not {}:
self.current_location = kwargs
gps.stop()
Clock.schedule_once(self.start_gps, self.gps_loc_interval)
def raise_error(self, error_title, error_text):
self.app.raise_error(error_title, error_text)
def raise_option_dialogue(self, option_title, option_text, options,
callback):
self.app.raise_option_dialogue(option_title, option_text, options,
callback)
def raise_numpad(self,
numpad_title,
callback,
units=None,
minimum=None,
maximum=None,
do_decimal=False):
self.app.raise_numpad(numpad_title, callback, units, minimum, maximum,
do_decimal)
# -*- 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'],
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__)
class NFCInterface:
def __init__(self, logger=None):
# Member variables
self.running = False
self.writing = False
self.write_data = [0] # 16bytes
self.nfc = Pn532_i2c()
self.db = None
self.logger = logger or logging.getLogger(__name__)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(12,GPIO.OUT, initial=0) # Red
GPIO.setup(15,GPIO.OUT, initial=0) # Green
# GPIO.cleanup()
# Initiate the PN532 module
self.logger.info('Initializing PN532 ...')
# Send a FirmwareVersion command
frame = Pn532Frame(frame_type=PN532_FRAME_TYPE_DATA, data=bytearray([PN532_COMMAND_GETFIRMWAREVERSION]))
self.nfc.send_command_check_ack(frame)
response = self.nfc.read_response()
# Ensure the SAM (Security Access Module) is basically off
self.nfc.SAMconfigure()
def red(self, state):
GPIO.output(12,state)
def green(self, state):
GPIO.output(15,state)
def blink(self, id, number, initial=0):
for x in range(0,number):
GPIO.output(id, initial)
sleep(0.2)
GPIO.output(id, not initial)
sleep(0.2)
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)
def stop(self):
self.logger.info('Stopping NFCInterface ...')
self.running = False
self.nfc.stop()
def set_writing(self, write_data):
self.logger.info('Received data to write')
self.red(1)
self.green(1)
#binprint.print_r_t(write_data, "Received: ")
self.writing = True
self.write_data = write_data
def get_uuid(self):
uuid_frame = self.nfc.read_mifare()
if uuid_frame is None:
return
else:
return uuid_frame.get_data()[-4:]
def mifare_auth(self, uuid, block):
if uuid is None:
return
# Apparently, before we can do anything at all, we must authenticate against the block.
# Arduino calls MifareAuthenticate, which wraps the command PN532_COMMAND_INDATAEXCHANGE
# (0x40) issued to pn532 with payload MIFARE_CMD_AUTH_A (0x60) on block.
auth_data = bytearray([0x40,0x01,0x60,block]) # PN532 + MiFare command
auth_data += bytearray([0xff,0xff,0xff,0xff,0xff,0xff]) # default auth KeyA
auth_data += uuid
frame = Pn532Frame(frame_type=PN532_FRAME_TYPE_DATA, data=auth_data)
self.nfc.send_command_check_ack(frame)
def mifare_read(self, block):
# Let's try and read a particular block, shall we?
# So, the Arduino code uses MifareReadBlock, which is a wrapper around the command
# PN532_COMMAND_INDATAEXCHANGE (0x40) issued to the pn532 controller logical relevant
# target 0x01, with the payload of MIFARE_CMD_READ (0x30) on block.
# Build the frame
frame = Pn532Frame(frame_type=PN532_FRAME_TYPE_DATA, data=bytearray([0x40,0x01,0x30,block]))
# Issue the command
self.nfc.send_command_check_ack(frame)
response = self.nfc.read_response()
return response.get_data()
def mifare_write(self, block, data):
# Write write write! What a risk.
# Arduino uses MifareWriteBlock; a wrapper around PN532_COMMAND_INDATAEXCHANGE (0x40)
# issued to pn532, logical relevant target 0x01, with a payload of MIFARE_CMD_WRITE
# (0xA0) on block.
# Then you've got 16 bytes you can fill with stuff and/or things.
write_data = bytearray([0x40,0x01,0xA0,block])
write_data += bytearray(data)
frame = Pn532Frame(frame_type=PN532_FRAME_TYPE_DATA, data=write_data)
self.nfc.send_command_check_ack(frame)
# -*- 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)
class DriveMainThread(Thread):
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 add_drive_widget(self, widget, folder_to_track):
assert (folder_to_track in self.folders_to_track)
tracked_widgets = self.tracked_widgets
if folder_to_track not in tracked_widgets:
tracked_widgets[folder_to_track] = [widget]
else:
tracked_widgets[folder_to_track].append(widget)
def setup_drive(self):
credentials = storage.get()
self.queue = queue = Queue.Queue()
if credentials is None:
flow = OAuth2WebServerFlow(CLIENT_ID,
CLIENT_SECRET,
OAUTH_SCOPE,
redirect_uri=REDIRECT_URI)
authorize_url = flow.step1_get_authorize_url()
print 'Go to the following link in your browser: ' + authorize_url
code = raw_input('Enter verification code: ').strip()
credentials = flow.step2_exchange(code)
storage.put(credentials)
http = httplib2.Http()
http = credentials.authorize(http)
self.drive_service = drive_service = build('drive', 'v2', http=http)
self.thread_pool = thread_pool = DriveThreadPool(1, queue, credentials)
def get_tracked_folder_ids(self, folders_to_track, address):
drive_data = self.drive_data
for folder_name in self.folders_to_track:
q = "title = '{}'".format(folder_name)
data = self.drive_service.children().list(folderId='root',
q=q).execute()
folder_add = address + folder_name + '/'
self.ensure_dir(folder_add)
#self.add_folder_observer(self.get_callback, unicode(folder_add))
for dat in data[u'items']:
item_id = dat[u'id']
drive_data.set_entry('folders', item_id, 'file_add',
folder_add)
drive_data.set_entry('tracked_items', item_id, 'file_add',
folder_add)
def check_file_in_tracked_folders(self, file_data):
parents = file_data[u'parents']
folders = self.drive_data.get_table('folders')
for parent in parents:
parent_id = parent[u'id']
if parent_id in folders:
return True
return False
def run(self):
while True:
query_download = self.update_queue.get()
if query_download:
self.retrieve_all_changes()
self.update_queue.task_done()
def download_folder(self, file_id, file_data):
parents = file_data[u'parents']
drive_data = self.drive_data
#save_data = self.save_data
folders = drive_data.get_table('folders')
get_entry = drive_data.get_entry
append_entry = drive_data.append_entry
for parent in parents:
parent_id = parent[u'id']
if parent_id in folders:
address = get_entry('folders', parent_id, 'file_add')
folder_name = file_data[u'title']
folder_add = address + folder_name + '/'
self.ensure_dir(folder_add)
append_entry('folders', file_id, 'file_add', folder_add)
append_entry('tracked_items', file_id, 'file_add', folder_add)
def place_address_in_queue(self, address, file_name, file_id,
time_since_epoch, download_url):
drive_data = self.drive_data
self.ensure_dir(address)
file_add = address + file_name
drive_data.append_entry('tracked_items', file_id, 'file_add', file_add)
do_download = False
try:
mod_time = os.stat(file_add).st_mtime
if time_since_epoch > mod_time:
do_download = True
else:
do_download = False
except:
do_download = True
if do_download:
self.queue.put(
(self._download, [download_url, file_add,
time_since_epoch], {}))
def download_file(self, file_id, file_data):
mod_date = file_data[u'modifiedDate']
parents = file_data[u'parents']
time_since_epoch = self.calculate_time_since_epoch(mod_date)
drive_data = self.drive_data
folders = drive_data.get_table('folders')
get_entry = drive_data.get_entry
download_url = file_data[u'downloadUrl']
file_name = file_data[u'title']
place_address_in_queue = self.place_address_in_queue
for parent in parents:
parent_id = parent[u'id']
if parent_id in folders:
address = get_entry('folders', parent_id, 'file_add')
if isinstance(address, list):
for add in address:
place_address_in_queue(add, file_name, file_id,
time_since_epoch, download_url)
else:
place_address_in_queue(address, file_name, file_id,
time_since_epoch, download_url)
def retrieve_all_changes(self):
result = []
page_token = None
drive_data = self.drive_data
largest_change = int(self.get_largest_change_id())
try:
start_change_id = str(
int(drive_data.get_entry('changes', 'last_change', 'id')) + 1)
except:
start_change_id = str(int(self.start_sync_at))
# if self.progress_tracker.start_change_id is None:
# self.progress_tracker.start_change_id = int(start_change_id)
# self.progress_tracker.last_change_id = int(start_change_id)
if largest_change >= int(start_change_id):
print('we should parse')
# Clock.schedule_once(partial(self.retrieve_page_of_changes, None,
# start_change_id))
while True:
param = {}
print('grabbing changes')
if start_change_id is not None:
param['startChangeId'] = start_change_id
if page_token is not None:
param['pageToken'] = page_token
changes = self.drive_service.changes().list(**param).execute()
self.parse_changes(changes)
#self.sync()
page_token = changes.get('nextPageToken')
if not page_token:
print('done breaking')
break
def parse_changes(self, changes):
drive_data = self.drive_data
download_folder = self.download_folder
download_file = self.download_file
remove_file = self.remove_file
tracked_items = drive_data.get_table('tracked_items')
check_file_in_tracked_folders = self.check_file_in_tracked_folders
get_is_folder = self.get_is_folder
set_entry = drive_data.set_entry
get_file = self.get_file
if len(changes['items']) == 0:
return None
for change in changes['items']:
file_id = change[u'fileId']
change_id = change[u'id']
file_data = get_file(file_id)
is_deleted = change[u'deleted']
if is_deleted and file_id in tracked_items:
self.handle_remove_callback(file_id)
remove_file(file_id)
if file_data != None:
if check_file_in_tracked_folders(file_data):
if get_is_folder(file_data):
download_folder(file_id, file_data)
else:
download_file(file_id, file_data)
set_entry('changes', 'last_change', 'id', change_id)
return change_id
def handle_remove_callback(self, file_id):
file_adds = self.drive_data.get_entry('tracked_items', file_id,
'file_add')
tracked_widgets = self.tracked_widgets
if file_adds is not None:
if isinstance(file_adds, list):
for file_add in file_adds:
widgets_for_removal = []
widgets_a = widgets_for_removal.append
dir_name = str(dirname(file_add) + '/')
for wid in tracked_widgets[dir_name]:
r_wid = wid()
if r_wid is not None:
file_callback = r_wid.file_callback
Clock.schedule_once(
partial(file_callback, file_add, True))
else:
widgets_a(wid)
for wid_ref in widgets_for_removal:
tracked_widgets[file_adds].remove(wid_ref)
def remove_file(self, file_id):
drive_data = self.drive_data
to_remove = []
to_remove_a = to_remove.append
remove_entry = drive_data.remove_entry
file_adds = drive_data.get_entry('tracked_items', file_id, 'file_add')
if file_adds is not None:
for file_add in file_adds:
try:
os.remove(file_add)
to_remove_a(file_add)
except:
continue
for add in to_remove:
remove_entry('tracked_items', file_id, 'file_add', add)
def ensure_dir(self, f):
d = os.path.dirname(f)
if not os.path.exists(d):
os.makedirs(d)
def calculate_time_since_epoch(self, drive_time):
date, current_time = drive_time.split('T')
year, month, day = date.split('-')
hours, minutes, seconds = current_time.split(':')
seconds = seconds.split('.')[0]
py_date = datetime.datetime(int(year),
int(month),
int(day),
hour=int(hours),
minute=int(minutes),
second=int(seconds))
return time.mktime(py_date.timetuple())
def get_is_folder(self, file_data):
return file_data[u'mimeType'] == u'application/vnd.google-apps.folder'
def get_file(self, fid):
try:
return self.drive_service.files().get(fileId=fid).execute()
except:
return None
def list_folder_content(self, fid):
return self.drive_service.children().list(folderId=fid).execute()
def get_about_data(self):
return self.drive_service.about().get().execute()
def get_largest_change_id(self):
return self.get_about_data()[u'largestChangeId']
def get_content_title(self, fid):
return self.drive_service.files().get(fileId=fid).execute()[u'title']
def _download(self, queue, drive_service, download_url, name, time):
if download_url:
try:
resp, content = drive_service._http.request(download_url)
except:
print 'An error occurred: '
return
if resp.status == 200:
with open(name, 'w') as save_file:
save_file.write(content)
os.utime(name, (os.stat(name).st_atime, time))
folder_name = os.path.dirname(name) + '/'
tracked_widgets = self.tracked_widgets
widgets_for_removal = []
widget_a = widgets_for_removal.append
if folder_name in tracked_widgets:
for wid in tracked_widgets[folder_name]:
r_wid = wid()
if r_wid is not None:
Clock.schedule_once(
partial(r_wid.file_callback, name, False), 15.)
else:
widget_a(wid)
for wid_ref in widgets_for_removal:
tracked_widgets[folder_name].remove(wid_ref)
queue.task_done()
else:
print 'An error occurred: %s' % resp
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)
class NFCInterface:
def __init__(self, logger=None):
# Member variables
self.running = False
self.writing = False
self.write_data = [0] # 16bytes
self.nfc = Pn532_i2c()
self.db = None
self.logger = logger or logging.getLogger(__name__)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(12, GPIO.OUT, initial=0) # Red
GPIO.setup(15, GPIO.OUT, initial=0) # Green
# GPIO.cleanup()
# Initiate the PN532 module
self.logger.info('Initializing PN532 ...')
# Send a FirmwareVersion command
frame = Pn532Frame(frame_type=PN532_FRAME_TYPE_DATA,
data=bytearray([PN532_COMMAND_GETFIRMWAREVERSION]))
self.nfc.send_command_check_ack(frame)
response = self.nfc.read_response()
# Ensure the SAM (Security Access Module) is basically off
self.nfc.SAMconfigure()
def red(self, state):
GPIO.output(12, state)
def green(self, state):
GPIO.output(15, state)
def blink(self, id, number, initial=0):
for x in range(0, number):
GPIO.output(id, initial)
sleep(0.2)
GPIO.output(id, not initial)
sleep(0.2)
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)
def stop(self):
self.logger.info('Stopping NFCInterface ...')
self.running = False
self.nfc.stop()
def set_writing(self, write_data):
self.logger.info('Received data to write')
self.red(1)
self.green(1)
#binprint.print_r_t(write_data, "Received: ")
self.writing = True
self.write_data = write_data
def get_uuid(self):
uuid_frame = self.nfc.read_mifare()
if uuid_frame is None:
return
else:
return uuid_frame.get_data()[-4:]
def mifare_auth(self, uuid, block):
if uuid is None:
return
# Apparently, before we can do anything at all, we must authenticate against the block.
# Arduino calls MifareAuthenticate, which wraps the command PN532_COMMAND_INDATAEXCHANGE
# (0x40) issued to pn532 with payload MIFARE_CMD_AUTH_A (0x60) on block.
auth_data = bytearray([0x40, 0x01, 0x60,
block]) # PN532 + MiFare command
auth_data += bytearray([0xff, 0xff, 0xff, 0xff, 0xff,
0xff]) # default auth KeyA
auth_data += uuid
frame = Pn532Frame(frame_type=PN532_FRAME_TYPE_DATA, data=auth_data)
self.nfc.send_command_check_ack(frame)
def mifare_read(self, block):
# Let's try and read a particular block, shall we?
# So, the Arduino code uses MifareReadBlock, which is a wrapper around the command
# PN532_COMMAND_INDATAEXCHANGE (0x40) issued to the pn532 controller logical relevant
# target 0x01, with the payload of MIFARE_CMD_READ (0x30) on block.
# Build the frame
frame = Pn532Frame(frame_type=PN532_FRAME_TYPE_DATA,
data=bytearray([0x40, 0x01, 0x30, block]))
# Issue the command
self.nfc.send_command_check_ack(frame)
response = self.nfc.read_response()
return response.get_data()
def mifare_write(self, block, data):
# Write write write! What a risk.
# Arduino uses MifareWriteBlock; a wrapper around PN532_COMMAND_INDATAEXCHANGE (0x40)
# issued to pn532, logical relevant target 0x01, with a payload of MIFARE_CMD_WRITE
# (0xA0) on block.
# Then you've got 16 bytes you can fill with stuff and/or things.
write_data = bytearray([0x40, 0x01, 0xA0, block])
write_data += bytearray(data)
frame = Pn532Frame(frame_type=PN532_FRAME_TYPE_DATA, data=write_data)
self.nfc.send_command_check_ack(frame)
class KivySurvey(ScreenManager):
current_page = ObjectProperty(None, allownone=True)
current_subjects = ListProperty(None, allownone=True)
db_interface = ObjectProperty(None)
current_subjects = ListProperty(None, allownone=True)
subject_id = NumericProperty(None, allownone=True)
previous_subject_ids = ListProperty(None, allownone=True)
current_page = ObjectProperty(None, allownone=True)
current_subjects_page = ObjectProperty(None, allownone=True)
next_page = StringProperty(None, allownone=True)
prev_page = StringProperty(None, allownone=True)
survey = ObjectProperty(None)
current_location = DictProperty({})
gps_loc_interval = NumericProperty(30.0)
questionnaire = StringProperty(None, allownone=True)
top_level_questionnaire = StringProperty(None, allownone=True)
root = ObjectProperty(None)
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 on_subject_id(self, instance, value):
self.load_subjects(value, self.questionnaire)
def create_subject(self):
db_interface = self.db_interface
uid = db_interface.get_unique_id()
prev_id = self.previous_subject_ids[-1]
db_interface.add_subject(prev_id, self.questionnaire, uid)
return uid
def pop_subjects(self):
previous_subject_ids = self.previous_subject_ids
if len(previous_subject_ids) > 0:
self.subject_id = self.previous_subject_ids.pop()
else:
self.subject_id = None
def on_questionnaire(self, instance, value):
self.load_subjects(self.subject_id, value)
self.current_subjects_page.allow_add_subject = (
self.survey.get_allow_add_subjects(value))
def load_subjects(self, subject_id, questionnaire):
self.current_subjects = self.db_interface.get_subjects(
subject_id, questionnaire)
def get_header_lines(self):
return self.survey.get_header_definitions(self.questionnaire)
def set_next_page(self):
survey = self.survey
next_page = survey.get_next_page(
self.questionnaire, self.current_page.page)
if next_page is None:
return False
else:
self.next_page = None
self.next_page = next_page
return True
def add_member(self):
self.transition.direction = 'left'
self.previous_subject_ids.append(self.subject_id)
self.subject_id = None
self.reset_questionnaire()
def open_member(self, member_id, instance):
self.transition.direction = 'left'
self.previous_subject_ids.append(self.subject_id)
self.subject_id = member_id
self.reset_questionnaire()
current_page = self.current_page.ids.questions
current_page.load_page_data()
def reset_questionnaire(self):
self.current_page.page = None
self.set_next_page()
self.swap_pages()
self.current_page.ids.questions.clear_questions()
def set_prev_page(self):
survey = self.survey
prev_page = survey.get_prev_page(
self.questionnaire, self.current_page.page)
if prev_page is None:
return False
else:
self.prev_page = prev_page
return True
def swap_subjects(self):
subjects1 = self.ids.subjects1
subjects2 = self.ids.subjects2
current_subjects_page = self.current_subjects_page
if current_subjects_page is subjects1:
self.current = 'subjects2'
self.current_subjects_page = subjects2
elif current_subjects_page is subjects2:
self.current = 'subjects1'
self.current_subjects_page = subjects1
self.current_subjects_page.allow_add_subject = (
self.survey.get_allow_add_subjects(self.questionnaire))
self.current_page.ids.scrollview.scroll_to_top()
def swap_pages(self):
questions1 = self.ids.questions1
questions2 = self.ids.questions2
current_page = self.current_page
if current_page is questions1:
self.current = 'questions2'
self.current_page = questions2
questions1.page = None
elif current_page is questions2:
self.current = 'questions1'
self.current_page = questions1
questions2.page = None
self.current_page.ids.scrollview.scroll_to_top()
def on_next_page(self, instance, value):
questions1 = self.ids.questions1
questions2 = self.ids.questions2
current_page = self.current_page
if current_page is questions1:
questions2.page = value
elif current_page is questions2:
questions1.page = value
def on_prev_page(self, instance, value):
questions1 = self.ids.questions1
questions2 = self.ids.questions2
current_page = self.current_page
if current_page is questions1:
questions2.page = value
elif current_page is questions2:
questions1.page = value
def start_questionnaire(self, questionnaire):
self.current_page.page = None
self.swap_subjects()
self.questionnaire = questionnaire
self.set_next_page()
def save_page(self):
current_page = self.current_page.ids.questions
current_page.save_page_data()
def go_back(self):
does_page_exist = self.set_prev_page()
survey = self.survey
questionnaire = self.questionnaire
prev_questionnaire = survey.get_previous_questionnaire()
self.transition.direction = 'right'
if self.current in ['subjects1', 'subjects2']:
if prev_questionnaire is None:
self.app.root.change_screen('cluster', go_back=True)
return
else:
if survey.get_allow_add_subjects(questionnaire):
self.pop_subjects()
self.start_questionnaire(survey.pop_previous_questionnaire())
elif does_page_exist:
self.swap_pages()
else:
if self.subject_id is None:
self.pop_subjects()
self.swap_subjects()
else:
self.pop_subjects()
self.swap_subjects()
def go_forward(self):
does_page_exist = self.set_next_page()
survey = self.survey
questionnaire = self.questionnaire
next_questionnaire = survey.get_next_questionnaire(questionnaire)
self.transition.direction = 'left'
if self.current in ['subjects1', 'subjects2']:
if next_questionnaire is None:
if survey.get_allow_add_subjects(questionnaire):
self.pop_subjects()
prev_questionnaire = survey.pop_previous_questionnaire()
self.start_questionnaire(prev_questionnaire)
else:
if survey.get_allow_forward(questionnaire):
survey.store_current_questionnaire(questionnaire)
self.start_questionnaire(next_questionnaire)
elif does_page_exist:
self.save_page()
self.swap_pages()
else:
is_creating_subject = False
if survey.get_allow_add_subjects(questionnaire) and (
self.subject_id is None):
self.subject_id = self.create_subject()
self.save_page()
if next_questionnaire is None:
self.pop_subjects()
prev_questionnaire = survey.pop_previous_questionnaire()
self.start_questionnaire(prev_questionnaire)
elif survey.get_allow_add_subjects(next_questionnaire):
survey.store_current_questionnaire(questionnaire)
self.start_questionnaire(next_questionnaire)
else:
self.pop_subjects()
self.swap_subjects()
def start_gps(self, dt):
try:
gps.start()
except:
pass
def receive_gps(self, **kwargs):
if kwargs is not {}:
self.current_location = kwargs
gps.stop()
Clock.schedule_once(self.start_gps, self.gps_loc_interval)
def raise_error(self, error_title, error_text):
self.app.raise_error(error_title, error_text)
def raise_option_dialogue(self, option_title, option_text, options,
callback):
self.app.raise_option_dialogue(option_title, option_text, options,
callback)
def raise_numpad(self, numpad_title, callback, units=None,
minimum=None, maximum=None, do_decimal=False):
self.app.raise_numpad(numpad_title, callback, units,
minimum, maximum, do_decimal)
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)
# -*- 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
class DriveMainThread(Thread):
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 add_drive_widget(self, widget, folder_to_track):
assert(folder_to_track in self.folders_to_track)
tracked_widgets = self.tracked_widgets
if folder_to_track not in tracked_widgets:
tracked_widgets[folder_to_track] = [widget]
else:
tracked_widgets[folder_to_track].append(widget)
def setup_drive(self):
credentials = storage.get()
self.queue = queue = Queue.Queue()
if credentials is None:
flow = OAuth2WebServerFlow(CLIENT_ID, CLIENT_SECRET, OAUTH_SCOPE,
redirect_uri=REDIRECT_URI)
authorize_url = flow.step1_get_authorize_url()
print 'Go to the following link in your browser: ' + authorize_url
code = raw_input('Enter verification code: ').strip()
credentials = flow.step2_exchange(code)
storage.put(credentials)
http = httplib2.Http()
http = credentials.authorize(http)
self.drive_service = drive_service = build('drive', 'v2', http=http)
self.thread_pool = thread_pool = DriveThreadPool(1, queue,
credentials)
def get_tracked_folder_ids(self, folders_to_track, address):
drive_data = self.drive_data
for folder_name in self.folders_to_track:
q="title = '{}'".format(folder_name)
data = self.drive_service.children().list(
folderId='root', q=q).execute()
folder_add = address+folder_name+'/'
self.ensure_dir(folder_add)
#self.add_folder_observer(self.get_callback, unicode(folder_add))
for dat in data[u'items']:
item_id = dat[u'id']
drive_data.set_entry(
'folders', item_id, 'file_add', folder_add)
drive_data.set_entry(
'tracked_items', item_id, 'file_add', folder_add)
def check_file_in_tracked_folders(self, file_data):
parents = file_data[u'parents']
folders = self.drive_data.get_table('folders')
for parent in parents:
parent_id = parent[u'id']
if parent_id in folders:
return True
return False
def run(self):
while True:
query_download = self.update_queue.get()
if query_download:
self.retrieve_all_changes()
self.update_queue.task_done()
def download_folder(self, file_id, file_data):
parents = file_data[u'parents']
drive_data = self.drive_data
#save_data = self.save_data
folders = drive_data.get_table('folders')
get_entry = drive_data.get_entry
append_entry = drive_data.append_entry
for parent in parents:
parent_id = parent[u'id']
if parent_id in folders:
address = get_entry('folders', parent_id, 'file_add')
folder_name = file_data[u'title']
folder_add = address+folder_name+'/'
self.ensure_dir(folder_add)
append_entry('folders', file_id, 'file_add', folder_add)
append_entry('tracked_items', file_id, 'file_add', folder_add)
def place_address_in_queue(self, address, file_name, file_id,
time_since_epoch, download_url):
drive_data = self.drive_data
self.ensure_dir(address)
file_add = address+file_name
drive_data.append_entry('tracked_items', file_id, 'file_add',
file_add)
do_download = False
try:
mod_time = os.stat(file_add).st_mtime
if time_since_epoch > mod_time:
do_download = True
else:
do_download = False
except:
do_download = True
if do_download:
self.queue.put((self._download, [download_url, file_add,
time_since_epoch], {}))
def download_file(self, file_id, file_data):
mod_date = file_data[u'modifiedDate']
parents = file_data[u'parents']
time_since_epoch = self.calculate_time_since_epoch(mod_date)
drive_data = self.drive_data
folders = drive_data.get_table('folders')
get_entry = drive_data.get_entry
download_url = file_data[u'downloadUrl']
file_name = file_data[u'title']
place_address_in_queue = self.place_address_in_queue
for parent in parents:
parent_id = parent[u'id']
if parent_id in folders:
address = get_entry('folders', parent_id, 'file_add')
if isinstance(address, list):
for add in address:
place_address_in_queue(add, file_name, file_id,
time_since_epoch, download_url)
else:
place_address_in_queue(address, file_name, file_id,
time_since_epoch, download_url)
def retrieve_all_changes(self):
result = []
page_token = None
drive_data = self.drive_data
largest_change = int(self.get_largest_change_id())
try:
start_change_id = str(int(
drive_data.get_entry('changes', 'last_change', 'id')) + 1)
except:
start_change_id = str(int(self.start_sync_at))
# if self.progress_tracker.start_change_id is None:
# self.progress_tracker.start_change_id = int(start_change_id)
# self.progress_tracker.last_change_id = int(start_change_id)
if largest_change >= int(start_change_id):
print('we should parse')
# Clock.schedule_once(partial(self.retrieve_page_of_changes, None,
# start_change_id))
while True:
param = {}
print('grabbing changes')
if start_change_id is not None:
param['startChangeId'] = start_change_id
if page_token is not None:
param['pageToken'] = page_token
changes = self.drive_service.changes().list(**param).execute()
self.parse_changes(changes)
#self.sync()
page_token = changes.get('nextPageToken')
if not page_token:
print('done breaking')
break
def parse_changes(self, changes):
drive_data = self.drive_data
download_folder = self.download_folder
download_file = self.download_file
remove_file = self.remove_file
tracked_items = drive_data.get_table('tracked_items')
check_file_in_tracked_folders = self.check_file_in_tracked_folders
get_is_folder = self.get_is_folder
set_entry = drive_data.set_entry
get_file = self.get_file
if len(changes['items']) == 0:
return None
for change in changes['items']:
file_id = change[u'fileId']
change_id = change[u'id']
file_data = get_file(file_id)
is_deleted = change[u'deleted']
if is_deleted and file_id in tracked_items:
self.handle_remove_callback(file_id)
remove_file(file_id)
if file_data != None:
if check_file_in_tracked_folders(file_data):
if get_is_folder(file_data):
download_folder(file_id, file_data)
else:
download_file(file_id, file_data)
set_entry('changes', 'last_change', 'id', change_id)
return change_id
def handle_remove_callback(self, file_id):
file_adds = self.drive_data.get_entry(
'tracked_items', file_id, 'file_add')
tracked_widgets = self.tracked_widgets
if file_adds is not None:
if isinstance(file_adds, list):
for file_add in file_adds:
widgets_for_removal = []
widgets_a = widgets_for_removal.append
dir_name = str(dirname(file_add) + '/')
for wid in tracked_widgets[dir_name]:
r_wid = wid()
if r_wid is not None:
file_callback = r_wid.file_callback
Clock.schedule_once(partial(file_callback,
file_add, True))
else:
widgets_a(wid)
for wid_ref in widgets_for_removal:
tracked_widgets[file_adds].remove(wid_ref)
def remove_file(self, file_id):
drive_data = self.drive_data
to_remove = []
to_remove_a = to_remove.append
remove_entry = drive_data.remove_entry
file_adds = drive_data.get_entry('tracked_items', file_id, 'file_add')
if file_adds is not None:
for file_add in file_adds:
try:
os.remove(file_add)
to_remove_a(file_add)
except:
continue
for add in to_remove:
remove_entry('tracked_items', file_id, 'file_add', add)
def ensure_dir(self, f):
d = os.path.dirname(f)
if not os.path.exists(d):
os.makedirs(d)
def calculate_time_since_epoch(self, drive_time):
date, current_time = drive_time.split('T')
year, month, day = date.split('-')
hours, minutes, seconds = current_time.split(':')
seconds = seconds.split('.')[0]
py_date = datetime.datetime(int(year), int(month), int(day),
hour=int(hours), minute=int(minutes),
second=int(seconds))
return time.mktime(py_date.timetuple())
def get_is_folder(self, file_data):
return file_data[u'mimeType'] == u'application/vnd.google-apps.folder'
def get_file(self, fid):
try:
return self.drive_service.files().get(fileId=fid).execute()
except:
return None
def list_folder_content(self, fid):
return self.drive_service.children().list(folderId=fid).execute()
def get_about_data(self):
return self.drive_service.about().get().execute()
def get_largest_change_id(self):
return self.get_about_data()[u'largestChangeId']
def get_content_title(self, fid):
return self.drive_service.files().get(fileId=fid).execute()[u'title']
def _download(self, queue, drive_service, download_url, name, time):
if download_url:
try:
resp, content = drive_service._http.request(download_url)
except:
print 'An error occurred: '
return
if resp.status == 200:
with open(name, 'w') as save_file:
save_file.write(content)
os.utime(name, (os.stat(name).st_atime,
time))
folder_name = os.path.dirname(name) + '/'
tracked_widgets = self.tracked_widgets
widgets_for_removal = []
widget_a = widgets_for_removal.append
if folder_name in tracked_widgets:
for wid in tracked_widgets[folder_name]:
r_wid = wid()
if r_wid is not None:
Clock.schedule_once(partial(r_wid.file_callback,
name, False), 15.)
else:
widget_a(wid)
for wid_ref in widgets_for_removal:
tracked_widgets[folder_name].remove(wid_ref)
queue.task_done()
else:
print 'An error occurred: %s' % resp