def home():
""" Shows the user's timeline or if no user is logged in it
will redirect to the user's public timeline (their most
recent posts) for public viewing. """
# Not logged in and multi-user mode.
if 'user_id' not in session and not settings.get('single_user_mode'):
return render_template('welcome.html')
# Not logged in and single-user mode.
elif 'user_id' not in session and settings.get('single_user_mode'):
user_id = settings.get('single_user_id')
username = settings.get_user(user_id)['username']
return redirect(url_for('get_user_profile', username=username))
# Logged in
elif 'user_id' in session:
user_id = session['user_id']
# Single-user mode, but no user yet.
elif settings.get('single_user_mode') and settings.get('single_user_id') is None:
return redirect(url_for('get_register'))
# Single-user mode, user exists.
else:
user_id = settings.get('single_user_id')
link = settings.get('registered_users').get(user_id).get('feed_location')
user = User(local_url=link)
posts = user.home_timeline()
auth = True if 'user_id' in session else False
return render_template('timeline.html', posts=posts, user=user,
page_type='timeline', auth=auth)
def __init__(self, iface):
"""Initialisation.
Parameters
----------
iface : QGisGui.QGisInterface
Instance of the QGis interface.
"""
# Save reference to the QGIS interface
self.iface = iface
self.qsettings = QtCore.QSettings()
self.settings = SettingsManager(self)
def post_status():
""" Adds a new post to the feed. """
form = request.form
status = Status()
status.description = form['status_text']
# Reply or Repost
repost = form.get('repost')
reply = form.get('reply')
if repost or reply:
status.reposted_user_id = form['user_id']
status.reposted_user_link = form['user_link']
if repost:
status.reposted_status_id = form['status_id']
status.reposted_status_pubdate = form['status_pubdate']
my_user_id = session['user_id']
my_user_dict = settings.get_user(my_user_id)
user = User(local_url=my_user_dict['feed_location'])
guid = uuid4().hex[-12:]
reply_url = '{0}/status/{1}/reply'.format(user.profile, guid)
status = Status({
'description': status_text,
'pubdate': datetime.now(pytz.UTC),
'guid': guid,
'reply': reply_url
})
user.add_post(status)
return redirect(url_for('home'))
def do_login():
""" Logs the user in. """
error = ''
username = request.form['username']
password = request.form['password']
username_and_ids = { ud['username']: uid for uid, ud in settings.get('registered_users').iteritems() }
if username not in username_and_ids.keys():
error = 'Invalid username'
pwd_hash = settings.get_user(username_and_ids[username]).get('pwd_hash')
if not check_password_hash(pwd_hash, password):
error = 'Invalid password'
else:
session['user_id'] = username_and_ids[username]
return redirect(url_for('home'))
return render_template('login.html', error=error)
def get_register():
""" Displays the reg page."""
if 'user_id' in session:
return redirect(url_for('home'))
elif settings.get('single_user_id') is not None:
return redirect(url_for('get_login'))
else:
return render_template('registration.html')
def __init__(self):
self.fileHandler: FileHandler = FileHandler()
self.sManager: SettingsManager = SettingsManager()
self.server: ServerManager = ServerManager()
self.scheduler: DeviceOpScheduler = DeviceOpScheduler()
self.logger: Logger = None
self.botClosing = False
def _populate_notebook(self):
# SETTINGS MANAGER PAGE INIT
self.settingsmanager = SettingsManager(self.notebook,
self,
self.init_cfg,
dbvar=None)
self.notebook.add(self.settingsmanager, text="Settings", sticky="nesw")
curr_config = self.settingsmanager.get_latest_config(needcopy=True)
# DATA MANAGER PAGE INIT
self.dbmanager = DBManager(self.notebook, self, curr_config)
self.notebook.add(self.dbmanager, text="DB Manager", sticky="nsew")
# PRODUCT VIEWER PAGE INIT
self.product_viewer_page = ProductViewer(
self.notebook, self, curr_config, dbvar=self.dbmanager.get_dbvar())
self.notebook.add(self.product_viewer_page, text="Product Viewer")
# ANALYSIS PAGE INIT
self.ap = AnalysisPage(self.notebook,
self,
curr_config,
dbvar=self.dbmanager.get_dbvar())
self.notebook.add(self.ap, text="Analysis", sticky="nsew")
# MULTIGRAPHER INIT
self.multigrapher = MultiGrapher(self.notebook, self, curr_config)
self.notebook.add(self.multigrapher,
text="MultiGrapher",
sticky="snew")
# Cafe24 INIT
self.cafe24manager = Cafe24Manager(self.notebook,
self,
curr_config,
user=self.account)
self.notebook.add(self.cafe24manager,
text="Cafe24 Manager",
sticky="snew")
# FINALIZE NOTEBOOK
self.notebook.grid(row=0, column=0, sticky="ENSW")
self.notebook.enable_traversal()
self.notebook.select(self.dbmanager)
def post_account():
# Flask apparently throws 400 errors if POST form data isn't present.
# Full name
user_id = session['user_id']
location = settings.get_user(user_id)['feed_location']
user = User(local_url=location)
if request.form.get('full_name_changed') == 'true':
user.full_name = request.form['full_name']
# Username
if request.form.get('username_changed') == 'true':
username= request.form['username']
if len(username) > 0:
user.username = username
# Bio
if request.form.get('bio_changed') == 'true':
user.description = request.form['bio']
# Email
if request.form.get('email_changed') == 'true':
email = request.form['email']
user_dict = settings.get_user(user_id)
user_dict['email'] = email
settings.add_user(user_dict)
# Password
if request.form.get('password_changed') == 'true':
password = request.form['password']
password_confirm = request.form['password_confirm']
if password == password_confirm:
user_dict = settings.get_user(user_id)
user_dict['pwd_hash'] = generate_password_hash(password)
settings.add_user(user_dict)
# Language
if request.form.get('language_changed') == 'true':
user.language = request.form['language']
return render_template('account.html', user=user, error='Your settings have been saved.')
def post_block():
""" Adds a new follow to the user's list. """
user_link = request.form['follow-url']
if user_link != '':
user_id = session.get('user_id')
user_dict = settings.get_user(user_id)
user = User(local_url=user_dict['feed_location'])
user.block(user_link=user_link)
return redirect(url_for('home'))
class ApiClient():
def __init__(self):
self.settings = SettingsManager()
self.baseUrl = "https://bartimeus-degoeie.herokuapp.com/api"
def activateNewSensor(self):
URL = self.baseUrl + "/cameras"
r = request.post(URL, data = { 'macAddress': get_mac() })
if r.status_code != 201:
print('Error during camera registering :( \n', r.text)
sys.exit()
result = r.json()
self.settings.setValue('key', result["id"])
self.settings.write()
return result['id']
def updateAvailability(self, cameraId, value):
print(value)
URL = self.baseUrl + "/cameras/detection"
realValue = None
if value:
realValue = 0
else:
realValue = 1
print("Value", realValue)
r = request.post(URL, data = {
"cameraId": cameraId,
"available": realValue
})
if r.status_code != 200:
print('Something went wrong with updating the room\'s availability.', r.text)
else:
print('Success.', r.text)
def post_unblock():
""" Unfollows a given user. """
user_link = request.form['user_link']
username = request.form['username']
user_id = request.form['user_id']
my_user_id = session.get('user_id')
user_dict = settings.get_user(my_user_id)
user = User(local_url=user_dict['feed_location'])
user.unblock(user_link=user_link, user_name=username, user_id=user_id)
return redirect(url_for('home'))
def test_refresh_and_has_changed(self):
#### No change
shutil.copy("settings_test.txt", "settings_test_has_changed.txt")
settings_has_changed = SettingsManager("settings_test_has_changed.txt")
self.assertEqual(settings_has_changed.refresh_and_has_changed(), False)
#### Edited key
with open("settings_test_has_changed.txt", "r") as file: lines = file.readlines()
lines[1] = "test = edited value\n"
with open("settings_test_has_changed.txt", "w") as file: file.writelines(lines)
self.assertEqual(settings_has_changed.refresh_and_has_changed(), True)
#### Added section and key
lines.append("\n")
lines.append("[new_section]\n")
lines.append("new_key = new value\n")
with open("settings_test_has_changed.txt", "w") as file: file.writelines(lines)
self.assertEqual(settings_has_changed.refresh_and_has_changed(), True)
#### Tidy files
os.remove("settings_test_has_changed.txt")
def __init__(self):
self.showWindows = None
self.parseArguments()
self.settings = SettingsManager()
self.motiondetector = MotionDetector(threshold=0.2,
showWindows=self.showWindows)
self.apiClient = ApiClient()
self.motion = False
self.timer = None
self.onTimer = Timer(7.0, self.resetOnTimer)
self.cameraId = None
self.motionScore = 0.0
self.initializeApp()
def test_new_file(self):
# Create file
new_settings = SettingsManager("new_file.txt")
file_exists = os.path.exists("new_file.txt")
self.assertEqual(file_exists, True)
# Add settings (save method is tested properly later)
new_settings.add_section("new_section")
new_settings.add_entry("new_key", "new value", "new_section")
new_settings.save()
file_exists = os.path.exists("new_file.txt")
self.assertEqual(file_exists, True)
# clean up file
os.remove("new_file.txt")
def main():
# Check the user's pid file to see if
# a crawler already exists.
if not os.path.exists(PID_LOCATION):
with open(PID_LOCATION, 'w') as f:
f.write('working')
print 'Starting...'
links = fr.get_user_follows_links()
links.append(fr.get_user_link())
print links
MicroblogFeedCrawler(links,
cache_location=SettingsManager.get('cache_location'),
start_now=True)
def __init__(self, argv):
super(QtWidgets.QApplication, self).__init__(argv)
self.setApplicationName("TV-Maxe")
self.setApplicationVersion("0.1a")
self.setOrganizationDomain("org.tv-maxe.app")
self.setOrganizationName("TV-Maxe")
log.info('{0} {1}'.format(self.applicationName(), self.applicationVersion()))
self.settings_manager = SettingsManager()
self.init_plugins()
log.debug('Current localization: {0}'.format(QtCore.QLocale.system().name()))
translator = QtCore.QTranslator()
translator.load("i18n/{0}.qm".format(QtCore.QLocale.system().name()))
self.installTranslator(translator)
self.mainw = TVMaxeMainWindow(None)
self.mainw.show()
def getGlobalPersonCharacteristic(self, charid=0, charname=""):
settingsmgr = SettingsManager()
char = settingsmgr.getPersonCharacteristic(charid, charname)
return char
def getGlobalHouseholdCharacteristics(self):
settingsmgr = SettingsManager()
chars = settingsmgr.getHouseholdCharacteristics()
return chars
def post_register():
""" Registers a new user. """
error = ''
user_full_name = request.form['full_name']
username = request.form['username']
password = request.form['password']
password_confirm = request.form['password_confirm']
email = request.form['email']
# User is already logged in.
if 'user_id' in session:
return redirect(url_for('home'))
# No more users can register.
elif settings.get('single_user_mode') \
and len(settings.get('registered_users')) > 0:
error = 'No more users can register at this time.'
# Username is alredy registered.
users = settings.get('registered_users')
username_taken = True if \
len([uid for uid, ud, in users.iteritems() if ud.get('username') == username]) > 0 \
else False
if username_taken:
return redirect(url_for('get_login'))
# Register the new user.
if username is None:
error = 'No username provided.'
elif len(username) < 8 or len(username) > 25:
error = 'Username is not the correct length. \
Please enter a username between 8-25 characters.'
elif re.search('[^a-zA-Z0-9\_]', username) is not None:
error = 'Usernames can only contain letters an numbers.'
elif re.search('\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}\b', email) is not None:
error = 'Please enter a valid email address.'
elif password is None or password_confirm is None:
error = 'You must fill in your password.'
elif password != request.form['password_confirm']:
error = 'Passwords do not match.'
elif len(password) < 8 or re.search('[a-zA-Z0-9]', password) is None:
error = 'Your password must be at least 8 characters long and \
must be a combination of numbers and letters. Special\
characters are allowed and encouraged.'
else:
new_user, feed_location, blocks_location, follows_location = User.create(username)
if settings.get('single_user_mode'):
settings.add('single_user_id', new_user.user_id)
domain = settings.get('domain')
new_user.profile = 'http://{0}/{1}'.format(domain, new_user.username)
new_user.link = 'http://{0}/{1}/feed.xml'.format(domain, new_user.username)
new_user.follows_url = 'http://{0}/{1}/follows.xml'.format(domain, new_user.username)
new_user.blocks_url = 'http://{0}/{1}/blocks.xml'.format(domain, new_user.username)
new_user.message_url = 'http://{0}/{1}/message.'.format(domain, new_user.username)
new_user.language = 'en'
# Update the settings.
pwd_hash = generate_password_hash(password)
settings.add_user(username=new_user.username,
pwd_hash=pwd_hash,
user_id=new_user.user_id,
feed_location=feed_location,
blocks_location=blocks_location,
follows_location=follows_location)
session['user_id'] = new_user.user_id
return redirect(url_for('home'))
return render_template('registration.html', error=error)
class Erosiebezwaren(object):
"""Main class of the Erosiebezwaren plugin.
Used to instanciate objects of the other classes and provide links between
them.
"""
def __init__(self, iface):
"""Initialisation.
Parameters
----------
iface : QGisGui.QGisInterface
Instance of the QGis interface.
"""
# Save reference to the QGIS interface
self.iface = iface
self.qsettings = QtCore.QSettings()
self.settings = SettingsManager(self)
def initGui(self):
"""Initialise the GUI of the plugin."""
# Create action that will start plugin configuration
self.action = QtGui.QAction('DOV - Erosiebezwaren',
self.iface.mainWindow())
# Add toolbar and menu item
self.toolbar = self.iface.addToolBar('Erosiebezwaren toolbar')
self.toolbar.setObjectName('ErosiebezwarenToolbar')
self.iface.addPluginToMenu('DOV - Erosiebezwaren', self.action)
self.utils = utils.Utils(self)
self.selectionManagerPolygons = SelectionManager(
self, self.settings.getValue('layers/tempSelectionPolygons'))
self.selectionManagerPoints = SelectionManager(
self, self.settings.getValue('layers/tempSelectionPoints'))
self.annotationManager = AnnotationManager(self)
self.actions = actions.Actions(self, self.iface.mainWindow(),
self.toolbar)
self.parcelInfoDock = ParcelInfoDock(self.iface.mainWindow())
self.parcelInfoWidget = ParcelInfoWidget(self.parcelInfoDock, self)
self.parcelInfoDock.setWidget(self.parcelInfoWidget)
def unload(self):
"""Unload the plugin.
Deactivate all loaded objectes in order to shut down properly.
"""
self.iface.removePluginMenu('DOV - Erosiebezwaren', self.action)
# FIXME: commented out to prevent segfault on QGis exit..?
# self.selectionManagerPolygons.deactivate()
# self.selectionManagerPoints.deactivate()
# self.annotationManager.deactivate()
self.actions.deactivate()
self.iface.removeDockWidget(self.parcelInfoDock)
del (self.actions)
del (self.toolbar)
del (self.parcelInfoWidget)
del (self.parcelInfoDock)
del (self.selectionManagerPolygons)
del (self.selectionManagerPoints)
del (self.annotationManager)
def __init__(self):
self.settings = SettingsManager()
self.baseUrl = "https://bartimeus-degoeie.herokuapp.com/api"
def setUp(self):
self.settings = SettingsManager("settings_test.txt")
def user_for_username(username):
for _, user_dict in settings.get('registered_users').iteritems():
if user_dict['username'] == username:
return user_dict
class TestSettingsManager(unittest.TestCase):
def setUp(self):
self.settings = SettingsManager("settings_test.txt")
def test_new_file(self):
# Create file
new_settings = SettingsManager("new_file.txt")
file_exists = os.path.exists("new_file.txt")
self.assertEqual(file_exists, True)
# Add settings (save method is tested properly later)
new_settings.add_section("new_section")
new_settings.add_entry("new_key", "new value", "new_section")
new_settings.save()
file_exists = os.path.exists("new_file.txt")
self.assertEqual(file_exists, True)
# clean up file
os.remove("new_file.txt")
def test_standard_read(self):
value = self.settings.general.test
self.assertEqual(value, "test value")
value = self.settings.general.test_boolean
self.assertEqual(value, True)
value = self.settings.general.test_int
self.assertEqual(value, 590)
value = self.settings.general.test_float
self.assertEqual(value, 1.989)
value = self.settings.space_test.test_two_spaces
self.assertEqual(value, "test3")
value = self.settings.space_before_section.test
self.assertEqual(value, "test value")
def test_new_section(self):
self.settings.add_section("new_section")
self.assertEqual(self.settings.new_section._name, "new_section")
self.settings.new_section.add_entry("new_key", "new value")
self.assertEqual(self.settings.new_section.new_key, "new value")
self.settings.add_entry("new_key2", "new value2", self.settings.new_section)
self.assertEqual(self.settings.new_section.new_key2, "new value2")
def test_add_entry(self):
#### Add to existing section
# add to section instance
self.settings.general.add_entry("new_key", "new value")
self.assertEqual(hasattr(self.settings.general, "new_key"), True)
self.assertEqual(self.settings.general.new_key, "new value")
# add to settings instance, with section instance
self.settings.add_entry("new_key2", "new value2", self.settings.general)
self.assertEqual(hasattr(self.settings.general, "new_key2"), True)
self.assertEqual(self.settings.general.new_key2, "new value2")
# add to settings instance, with section name
self.settings.add_entry("new_key3", "new value3", "general")
self.assertEqual(hasattr(self.settings.general, "new_key3"), True)
self.assertEqual(self.settings.general.new_key3, "new value3")
#### Add to non-existing section
self.assertRaises(ValueError, self.settings.add_entry, *["new_key", "new_value", None])
self.assertRaises(AttributeError, self.settings.add_entry, *["new_key", "new_value", "section_does_not_exist"])
#### Add an already existing key
self.assertRaises(AttributeError, self.settings.general.add_entry, *["new_key", "attempt to re-add"])
self.assertRaises(AttributeError, self.settings.add_entry, *["new_key2", "attempt to re-add", "general"])
def test_refresh(self):
#### Make changes and then reset to normal file
self.settings.general.test = "edited value" # changed from "test value"
self.settings.add_section("added_section")
self.settings.add_entry("added_key", "added value", "added_section")
self.settings.refresh()
self.assertEqual(self.settings.general.test, "test value")
self.assertRaises(AttributeError, self.settings.add_entry, *["key", "value", "added_section"])
def test_save(self):
#### Save an exact copy
self.settings.save("copied_settings_test.txt")
with open("settings_test.txt") as file: lines_before = file.readlines()
with open("copied_settings_test.txt") as file: lines_after = file.readlines()
self.assertListEqual(lines_before, lines_after)
#### Test file_path change after save
self.assertEqual(self.settings._file_path, "copied_settings_test.txt")
#### Save an edited copy
self.settings.general.test = "edited value"
self.settings.add_entry("new_key", "new value", "general")
self.settings.space_test.add_entry("new_key_spaces", "new value spaces")
self.settings.add_section("new_section")
self.settings.add_entry("key", "value", "new_section")
self.settings.add_entry("key2", "value2", "new_section")
self.settings.save("edited_settings_test.txt")
with open("settings_test.txt") as file: lines_before = file.readlines()
with open("edited_settings_test.txt") as file: lines_after = file.readlines()
self.assertNotEqual(lines_before, lines_after)
self.assertEqual(lines_after[1], "test = edited value\n")
self.assertEqual(lines_after[6], "new_key = new value\n")
self.assertEqual(lines_after[16], "new_key_spaces = new value spaces\n")
self.assertEqual(lines_after[23], "[new_section]\n")
self.assertEqual(lines_after[24], "key = value\n")
self.assertEqual(lines_after[25], "key2 = value2\n")
#### Save over an edited copy
self.settings.add_entry("key3", "value3", "new_section")
self.settings.save("edited_settings_test.txt")
with open("edited_settings_test.txt") as file: lines_after = file.readlines()
self.assertEqual(lines_after[26], "key3 = value3\n")
#### Clean up files
os.remove("copied_settings_test.txt")
os.remove("edited_settings_test.txt")
def test_get_sections(self):
sections = self.settings.get_sections()
section_names = [section.get_name() for section in sections]
expected_section_names = ["general", "space_test", "space_before_section"]
self.assertListEqual(section_names, expected_section_names)
def test_get_section(self):
section = self.settings.get_section("general")
self.assertEqual(section.get_name(), "general")
#### None existant section
self.assertRaises(AttributeError, self.settings.get_section, "does_not_exist")
def test_set_value(self):
self.settings.set_value("test", "changed value", "general")
self.assertEqual(self.settings.general.test, "changed value")
self.settings.set_value("test_boolean", False, self.settings.general)
self.assertEqual(self.settings.general.test_boolean, False)
self.settings.general.set_value("test_int", 999)
self.assertEqual(self.settings.general.test_int, 999)
#### New value
self.settings.set_value("new_key", "new value", "general")
self.assertEqual(self.settings.general.new_key, "new value")
#### Test errors
self.assertRaises(ValueError, self.settings.general.set_value, *[0, 0])
self.assertRaises(AttributeError, self.settings.set_value, *["new_key", "new value", "does_not_exist"])
def test_refresh_and_has_changed(self):
#### No change
shutil.copy("settings_test.txt", "settings_test_has_changed.txt")
settings_has_changed = SettingsManager("settings_test_has_changed.txt")
self.assertEqual(settings_has_changed.refresh_and_has_changed(), False)
#### Edited key
with open("settings_test_has_changed.txt", "r") as file: lines = file.readlines()
lines[1] = "test = edited value\n"
with open("settings_test_has_changed.txt", "w") as file: file.writelines(lines)
self.assertEqual(settings_has_changed.refresh_and_has_changed(), True)
#### Added section and key
lines.append("\n")
lines.append("[new_section]\n")
lines.append("new_key = new value\n")
with open("settings_test_has_changed.txt", "w") as file: file.writelines(lines)
self.assertEqual(settings_has_changed.refresh_and_has_changed(), True)
#### Tidy files
os.remove("settings_test_has_changed.txt")
def test_read_file(self):
#### Reset line lists
self.settings._lines_raw = None
self.settings._lines_cleaned = None
self.settings._read_file()
#### Spot check variables
self.assertEqual(self.settings._lines_raw[0], "[general]\n")
self.assertEqual(self.settings._lines_cleaned[0], "[general]")
self.assertEqual(self.settings._lines_raw[11], "test_space = test2\n")
self.assertEqual(self.settings._lines_cleaned[11], "test_space=test2")
self.assertEqual(len(self.settings._lines_raw), 20)
self.assertEqual(len(self.settings._lines_cleaned), 20)
def test_clean_file_lines(self):
self.assertEqual(self.settings._lines_cleaned[1], "test=test value")
def test_clear_attributes(self):
self.settings._clear_attributes()
self.assertEqual(hasattr(self.settings, "general"), False)
self.assertEqual(hasattr(self.settings, "space_test"), False)
self.assertEqual(hasattr(self.settings, "space_before_section"), False)
def test_set_section_end_index(self):
self.assertEqual(self.settings.general._end_index_in_file, 6)
self.assertEqual(self.settings.space_test._end_index_in_file, 15)
self.assertEqual(self.settings.space_before_section._end_index_in_file, 20)
def test_insert_line_into_section(self):
#### Insert into first section
self.settings._insert_line_into_section(self.settings.general, "test_line\n")
self.assertEqual(self.settings.general._start_index_in_file, 0)
self.assertEqual(self.settings.general._end_index_in_file, 7)
self.assertEqual(self.settings.space_test._start_index_in_file, 8)
self.assertEqual(self.settings.space_test._end_index_in_file, 16)
self.assertEqual(self.settings.space_before_section._start_index_in_file, 19)
self.assertEqual(self.settings.space_before_section._end_index_in_file, 21)
#### Insert into later section
self.settings._insert_line_into_section(self.settings.space_test, "test_line\n")
self.assertEqual(self.settings.general._start_index_in_file, 0)
self.assertEqual(self.settings.general._end_index_in_file, 7)
self.assertEqual(self.settings.space_test._start_index_in_file, 8)
self.assertEqual(self.settings.space_test._end_index_in_file, 17)
self.assertEqual(self.settings.space_before_section._start_index_in_file, 20)
self.assertEqual(self.settings.space_before_section._end_index_in_file, 22)
def test_insert_new_section_line(self):
new_section = Section("new_section")
self.settings._insert_new_section_line(new_section)
self.assertEqual(new_section._start_index_in_file, 21)
self.assertEqual(new_section._end_index_in_file, 22)
self.assertEqual(self.settings._lines_raw[20], "\n")
self.assertEqual(self.settings._lines_cleaned[20], "")
self.assertEqual(self.settings._lines_raw[21], "[new_section]\n")
self.assertEqual(self.settings._lines_cleaned[21], "[new_section]")
def test_get_name(self):
self.assertEqual(self.settings.general.get_name(), "general")
self.assertEqual(self.settings.space_test.get_name(), "space_test")
class DataInsightsApp(tk.Tk):
def __init__(self, account, init_config, ver=None, showlog=False):
# if showlog =
self.log = logging.getLogger(__name__).info
self.bug = logging.getLogger(__name__).debug
logging.info("DataInsightsApp init started.")
super().__init__()
self.log("Super init completed.")
self.account = account
self.log("Account id = {}".format(self.account))
# APP-VARS
self.init_cfg = init_config
# self.analysispages = []
# APP DETAILS
self.app_version_text = ver
self.developers_text = "Developed by Justin H Kim."
# BUILD GUI
self._build_mainframe()
self._populate_notebook()
self.columnconfigure(0, weight=1)
self.rowconfigure(0, weight=1)
self.update()
def _build_mainframe(self):
self.mainframe = tk.Frame(self)
self.mainframe.grid(row=0, column=0, sticky="ensw")
self.mainframe.columnconfigure(0, weight=1)
self.mainframe.rowconfigure(0, weight=1)
self.notebook = ttk.Notebook(self.mainframe)
def _populate_notebook(self):
# SETTINGS MANAGER PAGE INIT
self.settingsmanager = SettingsManager(self.notebook,
self,
self.init_cfg,
dbvar=None)
self.notebook.add(self.settingsmanager, text="Settings", sticky="nesw")
curr_config = self.settingsmanager.get_latest_config(needcopy=True)
# DATA MANAGER PAGE INIT
self.dbmanager = DBManager(self.notebook, self, curr_config)
self.notebook.add(self.dbmanager, text="DB Manager", sticky="nsew")
# PRODUCT VIEWER PAGE INIT
self.product_viewer_page = ProductViewer(
self.notebook, self, curr_config, dbvar=self.dbmanager.get_dbvar())
self.notebook.add(self.product_viewer_page, text="Product Viewer")
# ANALYSIS PAGE INIT
self.ap = AnalysisPage(self.notebook,
self,
curr_config,
dbvar=self.dbmanager.get_dbvar())
self.notebook.add(self.ap, text="Analysis", sticky="nsew")
# MULTIGRAPHER INIT
self.multigrapher = MultiGrapher(self.notebook, self, curr_config)
self.notebook.add(self.multigrapher,
text="MultiGrapher",
sticky="snew")
# Cafe24 INIT
self.cafe24manager = Cafe24Manager(self.notebook,
self,
curr_config,
user=self.account)
self.notebook.add(self.cafe24manager,
text="Cafe24 Manager",
sticky="snew")
# FINALIZE NOTEBOOK
self.notebook.grid(row=0, column=0, sticky="ENSW")
self.notebook.enable_traversal()
self.notebook.select(self.dbmanager)
def propagate_db_var_change(self, new_dbvar):
# Required when DBManager does full resets of its dbvar, meaning the
# correct dbvar now has a new id.
try:
self.product_viewer_page.set_dbvar(new_dbvar)
except AttributeError:
self.bug(
"Tried to send new db to productviewer, but it does not exist yet."
)
try:
self.ap.set_dbvar(new_dbvar)
except AttributeError:
self.bug(
"Tried to send new db to productviewer, but it does not exist yet."
)
def propagate_cfg_var_change(self, new_cfgvar):
self.dbmanager.set_cfgvar(new_cfgvar)
self.product_viewer_page.set_cfgvar(new_cfgvar)
self.ap.set_cfgvar(new_cfgvar)
def send_to_multigrapher(self, path, pack, slot):
self.log("Send_to_multigrapher for path: {}".format(path))
self.multigrapher.receive_image(path, pack)
def get_graph_path(self, request_pack):
self.ap.request_and_graph_data(request_pack)
return self.ap.export_png(outdir="exports\multigrapher")
def send_new_presets(self, multigrapher_cfg):
self.settingsmanager.set_new_presets(multigrapher_cfg)
def get_default_presets(self):
return self.settingsmanager.get_latest_config()["multigrapher"]
from werkzeug import check_password_hash, generate_password_hash
from flask_limiter import Limiter
from cachemanager import CacheManager
from settingsmanager import SettingsManager as settings
from model.user import User
from model.status import Status
from model.shared import db
# Init the application
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////etc/microblog/microblog.db'
limiter = Limiter(app)
db.init_app(app)
app.debug = True
app.secret_key = settings.get('secret')
CacheManager(cache_location=settings.get('cache_location'))
if not app.debug:
import logging
from logging import FileHandler
file_handler = FileHandler('error.log')
file_handler.setLevel(logging.WARNING)
from logging import Formatter
file_handler.setFormatter(Formatter(
'%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'))
app.logger.addHandler(file_handler)
for handler in app.logger.handlers:
limiter.logger.addHandler(handler)
def getGlobalHouseholdCharacteristic(self, charid=0, charname=""):
settingsmgr = SettingsManager()
char = settingsmgr.getHouseholdCharacteristic(charid, charname)
return char
def getGlobalPersonCharacteristics(self):
settingsmgr = SettingsManager()
chars = settingsmgr.getPersonCharacteristics()
return chars
def get_account():
""" Allows the user to make changes to their profile. """
user_id = session['user_id']
location = settings.get_user(user_id)['feed_location']
user = User(local_url=location)
return render_template('account.html', user=user)
def getCurrencies(self):
settingsmgr = SettingsManager()
currencies = settingsmgr.getCurrencies()
return currencies
class TestSettingsManager(unittest.TestCase):
def setUp(self):
self.settings = SettingsManager("settings_test.txt")
def test_get_keys(self):
section_keys = self.settings._get_keys()
self.assertListEqual(list(section_keys),
["general", "space_test", "space_before_section"])
general_keys = self.settings.general._get_keys()
self.assertListEqual(list(general_keys), [
"test", "test_boolean", "test_boolean2", "test_int", "test_float"
])
def test_get_attributes(self):
sections = self.settings.get_attributes()
expected_sections = {
"general": self.settings.general,
"space_test": self.settings.space_test,
"space_before_section": self.settings.space_before_section
}
self.assertDictEqual(sections, expected_sections)
attributes = self.settings.general.get_attributes()
expected_attributes = {
"test": "test value",
"test_boolean": True,
"test_boolean2": False,
"test_int": 590,
"test_float": 1.989
}
self.assertDictEqual(attributes, expected_attributes)
def test_convert_string_to_list(self):
string = "item1, item2,item3,item4"
expected_list = ["item1", "item2", "item3", "item4"]
self.assertListEqual(self.settings.convert_string_to_list(string),
expected_list)
def test_is_key_or_section_name_valid(self):
valid = self.settings._is_key_or_section_name_valid("valid_name")
self.assertEqual(valid, True)
valid = self.settings._is_key_or_section_name_valid(
"valid_with_numb3r5")
self.assertEqual(valid, True)
#### Exceptions
self.assertRaises(ValueError,
self.settings._is_key_or_section_name_valid, None)
self.assertRaises(ValueError,
self.settings._is_key_or_section_name_valid, 123)
self.assertRaises(ValueError,
self.settings._is_key_or_section_name_valid, "")
self.assertRaises(ValueError,
self.settings._is_key_or_section_name_valid,
"_invalid")
self.assertRaises(ValueError,
self.settings._is_key_or_section_name_valid,
"123_invalid")
self.assertRaises(ValueError,
self.settings._is_key_or_section_name_valid,
"invalid!")
self.assertRaises(ValueError,
self.settings._is_key_or_section_name_valid,
"invalid)")
self.assertRaises(ValueError,
self.settings._is_key_or_section_name_valid,
"invalid?")
self.assertRaises(ValueError,
self.settings._is_key_or_section_name_valid,
"invalid=")
self.assertRaises(ValueError,
self.settings._is_key_or_section_name_valid,
"invalid.")
self.assertRaises(ValueError,
self.settings._is_key_or_section_name_valid,
"invalid,")
self.assertRaises(ValueError,
self.settings._is_key_or_section_name_valid,
"invalid*")
def test_is_line_a_heading(self):
string = "[is_heading]"
self.assertEqual(self.settings._is_line_a_heading(string), True)
string = "[y]"
self.assertEqual(self.settings._is_line_a_heading(string), True)
string = "[]"
self.assertEqual(self.settings._is_line_a_heading(string), False)
string = "[not_heading"
self.assertEqual(self.settings._is_line_a_heading(string), False)
string = "not_heading"
self.assertEqual(self.settings._is_line_a_heading(string), False)
string = "not a heading"
self.assertEqual(self.settings._is_line_a_heading(string), False)
def test_get_heading_from_line(self):
string = "[heading]"
self.assertEqual(self.settings._get_heading_from_line(string),
"heading")
def test_clean_line(self):
line_before = "key = value \n"
line_after_expected = "key=value"
self.assertEqual(self.settings._clean_line(line_before),
line_after_expected)
line_before = "key = value \n"
line_after_expected = "key= value"
self.assertEqual(self.settings._clean_line(line_before),
line_after_expected)
def test_is_line_an_entry(self):
string = "key=value"
self.assertEqual(self.settings._is_line_an_entry(string), True)
string = "key = value"
self.assertEqual(self.settings._is_line_an_entry(string), True)
string = "valid_key0 = value"
self.assertEqual(self.settings._is_line_an_entry(string), True)
string = "key = value, with punctuation!"
self.assertEqual(self.settings._is_line_an_entry(string), True)
string = "# obvious comment"
self.assertEqual(self.settings._is_line_an_entry(string), False)
string = "# comment = comment"
self.assertEqual(self.settings._is_line_an_entry(string), False)
string = "no equals sign"
self.assertEqual(self.settings._is_line_an_entry(string), False)
def test_get_key_from_line(self):
string = "key = value"
self.assertEqual(self.settings._get_key_from_line(string), "key")
string = "key=value"
self.assertEqual(self.settings._get_key_from_line(string), "key")
string = "valid_key012 = value"
self.assertEqual(self.settings._get_key_from_line(string),
"valid_key012")
string = "# key = value commented out"
self.assertEqual(self.settings._get_key_from_line(string), None)
def test_get_value_from_line(self):
string = "key = value"
self.assertEqual(self.settings._get_value_from_line(string), "value")
string = "key=value"
self.assertEqual(self.settings._get_value_from_line(string), "value")
string = "key = value with multiple words!"
self.assertEqual(self.settings._get_value_from_line(string),
"value with multiple words!")
string = "boolean = True"
self.assertEqual(self.settings._get_value_from_line(string), True)
string = "integer = 12345"
self.assertEqual(self.settings._get_value_from_line(string), 12345)
string = "float = 12.345"
self.assertEqual(self.settings._get_value_from_line(string), 12.345)
string = "string = 12.345!"
self.assertEqual(self.settings._get_value_from_line(string), "12.345!")
string = "# commented_out = value"
self.assertEqual(self.settings._get_value_from_line(string), None)
def test_attempt_parse_bool(self):
input = "True"
self.assertEqual(self.settings._attempt_parse_bool(input), True)
input = "False"
self.assertEqual(self.settings._attempt_parse_bool(input), False)
input = "string"
self.assertEqual(self.settings._attempt_parse_bool(input), "string")
input = 123
self.assertEqual(self.settings._attempt_parse_bool(input), 123)
def test_attempt_parse_int(self):
input = "123"
self.assertEqual(self.settings._attempt_parse_int(input), 123)
input = 123
self.assertEqual(self.settings._attempt_parse_int(input), 123)
input = "string"
self.assertEqual(self.settings._attempt_parse_int(input), "string")
input = "True"
self.assertEqual(self.settings._attempt_parse_int(input), "True")
def test_attempt_parse_float(self):
input = "123.456"
self.assertEqual(self.settings._attempt_parse_float(input), 123.456)
input = 123
self.assertEqual(self.settings._attempt_parse_float(input), 123)
input = "string"
self.assertEqual(self.settings._attempt_parse_float(input), "string")
input = "True"
self.assertEqual(self.settings._attempt_parse_float(input), "True")
def test_generate_file_line(self):
self.assertEqual(self.settings._generate_file_line("key", "value"),
"key = value\n")
def main():
os.system('cls' if os.name == 'nt' else 'clear')
print '''
=========================================
{0}Welcome to Microblogger{1}
=========================================
This installer will guide you through configuring your new Microblogger.
The installation has 2 short parts:
- Apache setup (for the website)
- Crawler setup (for the ability to read other people's feeds)
Microblogger runs on Apache. To install Microblogger on anything else,
you will need to manually install and configure the service.
Before beginning, please create a new user for Microblogger to run under.
For security reasons, Apache will run Microblogger under a different user.
In Linux, this can be done by following the instructions here:
http://www.cyberciti.biz/faq/howto-add-new-linux-user-account/
Have you already done this? (y/N)
'''.format(bcolors.HEADER, bcolors.ENDC)
ans = raw_input('>>')
if 'y' not in ans.lower():
print '''
Please complete this step and try again.
'''
sys.exit()
# Apache config.
print '''
=========================================
{0}Microblog User Setup{1}
=========================================
Microblog user (Linux user, created above):
'''.format(bcolors.HEADER, bcolors.ENDC)
user = raw_input('>>')
while not validate_user(user):
print '''
{0}[Error]{1} Please input a valid username.
'''.format(bcolors.FAIL, bcolors.ENDC)
user = raw_input('>>')
print '''
Configuring...
Creating caches...
'''
# Add the user's path to the settings file.
global SETTINGS
SETTINGS = os.path.expanduser(SETTINGS.format(user))
CacheManager.create_cache(CACHE)
SettingsManager(SETTINGS)
SettingsManager.add('default_timeline_size', DEFAULT_TIMELINE_SIZE)
SettingsManager.add('max_feed_size_bytes', MAX_FILE_SIZE_BYTES)
SettingsManager.add('max_posts_per_feed', MAX_POSTS_PER_FEED)
SettingsManager.add('cache_location', CACHE)
# Create a secret key.
SettingsManager.add('secret', os.urandom(64).encode('base-64'))
print ' {0}OK{1}'.format(bcolors.OKGREEN, bcolors.ENDC)
print '''
=========================================
{0}Automatic Apache Installation{1}
=========================================
Use default web location? (y/N)
i.e. {2}
'''.format(bcolors.HEADER, bcolors.ENDC, ROOT_DIR)
defaults = raw_input('>>')
location = ''
if 'n' in defaults.lower():
print '''
File paths must already exist, and be accessable to Apache.
Paths should be in the form /path/to/web/location.
The path should also be a directory.
Plese input the location:'''
location = raw_input('>>')
while not os.path.exists(location) and os.path.isdir(location):
print 'Path is not valid. Enter a valid path.'
location = raw_input('Location: ')
else:
location = ROOT_DIR
# Append the trailing /
if not location[-1] == '/':
location + '/'
# Get the admin info.
print '''
What email address can we send errors to?
'''
email = raw_input('>>')
print '''
What is the desired server name?
i.e. microblog.mydomain.com
'''
domain = raw_input('>>')
# Create the custom Apache conf.
conf = ''
with open('bin/httpd.conf-addition', 'r') as f:
conf = f.read()
conf = conf.replace('{{WSGI_USER}}', user)\
.replace('{{WSGI_STATIC_DIR}}', location + 'static')\
.replace('{{WSGI_FEED_DIR}}', location + 'feed')\
.replace('{{WSGI_DIR}}', location)\
.replace('{{WSGI_FILE_LOCATION}}', location + 'microblogger.wsgi')\
.replace('{{ADMIN_EMAIL}}', email)\
.replace('{{SERVER_NAME}}', domain)
print '''
Do you want to automatically install the Apache configuration? (y/N)
(Manual install is reccommended for systems with lots of custom
Apache configurations)'''
ans = raw_input('>>')
if 'y' not in ans.lower():
print_manual_conf(conf)
sys.exit()
else:
# Write the apache conf to file.
print '''
Is your Apache conf file in the default location
(i.e. /etc/httpd/conf/httpd.conf)? (y/N)
'''
ans = raw_input('>>')
httpd_location = '/etc/httpd/conf/httpd.conf'
if 'y' not in ans.lower():
print '''
Where is it then?
'''
httpd_location = raw_input('>>')
while not os.path.isfile(httpd_location):
print '''
That location isn\'t valid.\n\
Please enter a valid location. (A)bort
'''
httpd_location = raw_input('>>')
if 'a' == httpd_location.lower():
sys.exit()
# Write the conf file.
old_httpd_conf = ''
try:
with open(httpd_location, 'a+') as f:
old_httpd_conf = f.read()
if conf not in old_httpd_conf:
f.write(conf)
except IOError:
print '''
{0}[Error]{1}
It looks like you don't have permission to edit {2}.
If you can, edit your permissions and try again.
Nothing has been changed.
If you do not have permission to do this, please contact your sysadmin.
If the problem persists, try the manual installation option.
{3}[Advanced users only]{4} If you're confident that you won't
accidentally mess something up, you can sudo this script and
it should work.
'''.format(bcolors.FAIL, bcolors.ENDC, httpd_location, bcolors.WARNING, bcolors.ENDC)
sys.exit()
# Check the Apache install.
from subprocess import call
print '''
=========================================
{0}Apache Syntax Check{1}
=========================================
...
'''.format(bcolors.HEADER, bcolors.ENDC)
res = call(['apachectl', '-t'])
# Rollback if there's any problem.
if res > 0:
print '''
{0}[Error]{1} Something went wrong installing Microblogger in Apache.
Rolling back httpd.conf.
Check your apache conf file, then try again.
'''.format(bcolors.FAIL, bcolors.ENDC)
with open(httpd_location, 'w') as f:
f.write(old_httpd_conf)
print_manual_conf(conf)
sys.exit()
print '''
Apache file: {0}[OK]{1}
Press any enter to continue.
'''.format(bcolors.OKGREEN, bcolors.ENDC)
raw_input('>>')
# Make the wsgi and cp it to the root of the web server.
with open('bin/microblogger.wsgi', 'r') as f1:
contents = f1.read()
contents = contents.replace('{{WSGI_FILE_LOCATION}}', location)
with open('microblogger.wsgi', 'w') as f2:
f2.write(contents)
# Crawler Crontab Setup.
print '''
=========================================
{0}Web Crawler Setup{1}
=========================================
Setting up the crawler. This allows you to read other people's
feeds and see their responses to you.
The crawler is run as a cron job under the user specified
for Apache earlier.
Press enter to continue.
'''.format(bcolors.HEADER, bcolors.ENDC)
raw_input('>>')
cron = CronTab(user=user)
# Create a job to run the crawler.
job = cron.new(command='/usr/bin/python {0}'.format(location + 'startcrawler.py'),
comment='Microblogger: Runs the crawler automatically.')
job.minute.every(1)
# Check it's validity.
if not job.is_valid:
print '''
{0}[Error]{1} Cron job is not valid.
Exiting
'''.format(bcolors.FAIL, bcolors.ENDC)
sys.exit()
cron.write()
# Setup complete
print '''
=================================
{0}Setup complete{1}
==================================
Thank you for installing Microblogger. Welcome to the wonderful world
of open, tamper-free communication.
If you have any questions about Microblogger, please contact me via...
Email: {2}[email protected]{3}
OR
Microblogger: {2}@sonicrocketman{3}
Please restart Apache to begin using Microblogger.
'''.format(bcolors.HEADER, bcolors.ENDC, bcolors.OKBLUE, bcolors.ENDC)
def classFactory(iface):
from settingsmanager import SettingsManager
return SettingsManager(iface)
