def editItem(category_name, item_name):
editedItem = session.query(Items).filter_by(name=item_name).one()
categories = session.query(Category).all()
# See if the logged in user is the owner of item
creator = getUserInfo(editedItem.user_id)
user = getUserInfo(login_session['user_id'])
# If logged in user != item owner redirect them
if creator.id != login_session['user_id']:
flash ("You cannot edit this item. This item belongs to %s" % creator.name)
return redirect(url_for('showCatalog'))
# POST methods
if request.method == 'POST':
if request.form['name']:
editedItem.name = request.form['name']
if request.form['description']:
editedItem.description = request.form['description']
if request.form['picture']:
editedItem.picture = request.form['picture']
if request.form['category']:
category = session.query(Category).filter_by(name=request.form['category']).one()
editedItem.category = category
time = datetime.datetime.now()
editedItem.date = time
session.add(editedItem)
session.commit()
flash('Category Item Successfully Edited!')
return redirect(url_for('showCategory',
category_name=editedItem.category.name))
else:
return render_template('edititem.html',
item=editedItem,
categories=categories)
def gdisconnect():
# Only disconnect a connected user.
access_token = login_session.get('access_token')
if access_token is None:
response = make_response(
json.dumps('Current user not connected.'), 401)
response.headers['Content-Type'] = 'application/json'
return response
url = 'https://accounts.google.com/o/oauth2/revoke?token=%s' % access_token
h = httplib2.Http()
result = h.request(url, 'GET')[0]
if result['status'] == '200':
# Reset the user's sesson.
del login_session['access_token']
del login_session['gplus_id']
del login_session['username']
del login_session['email']
del login_session['picture']
# response = make_response(json.dumps('Successfully disconnected.'), 200)
# response.headers['Content-Type'] = 'application/json'
response = redirect(url_for('showCatalog'))
flash("You are now logged out.")
return response
else:
# For whatever reason, the given token was invalid.
response = make_response(
json.dumps('Failed to revoke token for given user.', 400))
response.headers['Content-Type'] = 'application/json'
return response
def addCategory():
if request.method == 'POST':
newCategory = Category(
name=request.form['name'],
user_id=login_session['user_id'])
print (newCategory)
session.add(newCategory)
session.commit()
flash('Category Successfully Added!')
return redirect(url_for('showCatalog'))
else:
return render_template('addcategory.html')
def resubmit(request, submission_id):
submission = models.Submission.get_by_id(submission_id)
if submission is None or submission.account.key().id() != local.account.key().id():
logging.warning('Attempt to resubmit submission "%s" by account "%s" with email "%s".' % (submission_id, local.account.key().id(), local.account.email))
return redirect(url_for('main/index'))
if request.method == "POST":
form = forms.ResubmissionForm(request.form)
if form.validate():
submission.text_list.append(db.Text(utils.text_tidy(form.text.data)))
submission.put()
flash("Your submission has been updated.")
return redirect(url_for('home/preview', submission_id=submission.key().id()))
else:
form = forms.ResubmissionForm(obj=submission)
return render_response('resubmit.html', form=form, submission=submission)
def submit(request):
if request.method == "POST":
form = forms.SubmissionForm(request.form)
if form.validate():
submission = models.Submission(account=local.account,
simultaneous=form.simultaneous.data,
cover_letter=db.Text(utils.text_tidy(form.cover_letter.data)),
title=utils.text_tidy(form.title.data),
text_list=[db.Text(utils.text_tidy(form.text.data))],
categories=form.categories.data)
submission.put()
flash("Your submission has been saved.")
return redirect(url_for('home/preview', submission_id=submission.key().id()))
else:
form = forms.SubmissionForm()
return render_response('submit.html', form=form)
def __init__(self, ui, dbgio):
self.ui = ui
self.dbgio = dbgio
self.device = vendor.get_device(self.ui, soc_name)
self.dbgio.connect(self.device.cpu_info.name, "swd")
self.cpu = cortexm.cortexm(self, ui, self.dbgio, self.device)
self.device.bind_cpu(self.cpu)
self.mem = mem.mem(self.cpu)
self.flash = flash.flash(flash_driver.stm32f0xx(self.device), self.device, self.mem)
gpio_drv = gpio_driver.drv(self.device, gpio_cfg)
self.gpio = gpio.gpio(gpio_drv)
self.i2c = i2c.i2c(i2c_driver.gpio(gpio_drv, "PB6", "PB7"))
self.menu_root = (
("cpu", self.cpu.menu, "cpu functions"),
("da", self.cpu.cmd_disassemble, cortexm.help_disassemble),
("debugger", self.dbgio.menu, "debugger functions"),
("exit", self.cmd_exit),
("flash", self.flash.menu, "flash functions"),
("go", self.cpu.cmd_go),
("gpio", self.gpio.menu, "gpio functions"),
("halt", self.cpu.cmd_halt),
("help", self.ui.cmd_help),
("history", self.ui.cmd_history, cli.history_help),
("i2c", self.i2c.menu, "i2c functions"),
("map", self.device.cmd_map),
("mem", self.mem.menu, "memory functions"),
("program", self.flash.cmd_program, flash.help_program),
("regs", self.cmd_regs, soc.help_regs),
("vtable", self.cpu.cmd_vtable),
)
self.ui.cli.set_root(self.menu_root)
self.set_prompt()
self.dbgio.cmd_info(self.ui, None)
def __init__(self, ui, dbgio):
self.ui = ui
self.dbgio = dbgio
self.device = vendor.get_device(self.ui, soc_name)
self.dbgio.connect(self.device.cpu_info.name, 'swd')
self.cpu = cortexm.cortexm(self, ui, self.dbgio, self.device)
self.device.bind_cpu(self.cpu)
self.mem = mem.mem(self.cpu)
self.flash = flash.flash(flash_driver.flash(self.device), self.device, self.mem)
self.menu_root = (
('cpu', self.cpu.menu, 'cpu functions'),
('da', self.cpu.cmd_disassemble, cortexm.help_disassemble),
('debugger', self.dbgio.menu, 'debugger functions'),
('exit', self.cmd_exit),
('flash', self.flash.menu, 'flash functions'),
('go', self.cpu.cmd_go),
('halt', self.cpu.cmd_halt),
('help', self.ui.cmd_help),
('history', self.ui.cmd_history, cli.history_help),
('map', self.device.cmd_map),
('mem', self.mem.menu, 'memory functions'),
('program', self.flash.cmd_program, flash.help_program),
('regs', self.cmd_regs, soc.help_regs),
('vtable', self.cpu.cmd_vtable),
)
self.ui.cli.set_root(self.menu_root)
self.set_prompt()
self.dbgio.cmd_info(self.ui, None)
def __init__(self, ui, dbgio):
self.ui = ui
self.dbgio = dbgio
self.device = vendor.get_device(self.ui, soc_name)
self.dbgio.connect(self.device.cpu_info.name, 'swd')
self.cpu = cortexm.cortexm(self, ui, self.dbgio, self.device)
self.device.bind_cpu(self.cpu)
self.mem = mem.mem(self.cpu)
self.flash = flash.flash(flash_driver.stm32l4x2(self.device),
self.device, self.mem)
gpio_drv = (gpio_driver.drv(self.device, gpio_cfg))
self.gpio = gpio.gpio(gpio_drv)
self.menu_root = (
('cpu', self.cpu.menu, 'cpu functions'),
('da', self.cpu.cmd_disassemble, cortexm.help_disassemble),
('debugger', self.dbgio.menu, 'debugger functions'),
('exit', self.cmd_exit),
('flash', self.flash.menu, 'flash functions'),
('go', self.cpu.cmd_go),
('gpio', self.gpio.menu, 'gpio functions'),
('halt', self.cpu.cmd_halt),
('help', self.ui.cmd_help),
('history', self.ui.cmd_history, cli.history_help),
('map', self.device.cmd_map),
('mem', self.mem.menu, 'memory functions'),
('program', self.flash.cmd_program, flash.help_program),
('regs', self.cmd_regs, soc.help_regs),
('vtable', self.cpu.cmd_vtable),
)
self.ui.cli.set_root(self.menu_root)
self.set_prompt()
self.dbgio.cmd_info(self.ui, None)
def deleteCategory(category_name):
categoryToDelete = session.query(Category).filter_by(name=category_name).one()
# See if the logged in user is the owner of item
creator = getUserInfo(categoryToDelete.user_id)
user = getUserInfo(login_session['user_id'])
# If logged in user != item owner redirect them
if creator.id != login_session['user_id']:
flash ("You cannot delete this Category. This Category belongs to %s" % creator.name)
return redirect(url_for('showCatalog'))
if request.method =='POST':
session.delete(categoryToDelete)
session.commit()
flash('Category Successfully Deleted! '+categoryToDelete.name)
return redirect(url_for('showCatalog'))
else:
return render_template('deletecategory.html',
category=categoryToDelete)
def addItem():
categories = session.query(Category).all()
if request.method == 'POST':
newItem = Items(
name=request.form['name'],
description=request.form['description'],
picture=request.form['picture'],
category=session.query(Category).filter_by(name=request.form['category']).one(),
date=datetime.datetime.now(),
user_id=login_session['user_id'])
session.add(newItem)
session.commit()
flash('Item Successfully Added!')
return redirect(url_for('showCatalog'))
else:
return render_template('additem.html',
categories=categories)
def render_profile(request, template_name, redirect_url):
if request.method == "POST":
form = forms.ProfileForm(request.form)
if form.validate():
provided = False
if form.full_name.data:
local.account.full_name = form.full_name.data
provided = True
if form.alternate_email.data:
local.account.alternate_email = form.alternate_email.data
provided = True
if provided:
local.account.put()
flash("Your profile information has been saved.")
return redirect(redirect_url)
else:
form = forms.ProfileForm(obj=local.account)
return render_response(template_name, form=form)
def editCategory(category_name):
editedCategory = session.query(Category).filter_by(name=category_name).one()
category = session.query(Category).filter_by(name=category_name).one()
# See if the logged in user is the owner of item
creator = getUserInfo(editedCategory.user_id)
user = getUserInfo(login_session['user_id'])
# If logged in user != item owner redirect them
if creator.id != login_session['user_id']:
flash ("You cannot edit this Category. This Category belongs to %s" % creator.name)
return redirect(url_for('showCatalog'))
# POST methods
if request.method == 'POST':
if request.form['name']:
editedCategory.name = request.form['name']
session.add(editedCategory)
session.commit()
flash('Category Item Successfully Edited!')
return redirect(url_for('showCatalog'))
else:
return render_template('editcategory.html',
categories=editedCategory,
category = category)
def main(argv):
try:
opts, args = getopt.getopt(argv,"hi:","ifile=")
except getopt.GetoptError:
print 'commotion-router-testbench.py -i <inputfile>'
sys.exit(2)
if(len(opts) == 0):
print 'commotion-router-testbench.py -i <inputfile>'
sys.exit()
for opt, arg in opts:
if opt in ("-h", "--help"):
print 'commotion-router-testbench.py -i <inputfile>'
sys.exit()
elif opt in ("-i", "--ifile"):
inputFile = arg
## We will not move the files (try to do it through jenkins or something?)
# Copy new build to the tftp server (overwrite older builds)
# openwrt-ar71xx-generic-hornet-ub-x2-kernel.bin
#os.system("cp " + kernelPath + " " + tftpPath + "kernel.bin")
# openwrt-ar71xx-generic-hornet-ub-x2-rootfs-squashfs.bin
#os.system("cp " + rootfsPath + " " + tftpPath + "rootfs.bin")
# Read from input file the serial ports (routers) to communicate with
file = open(inputFile, 'r')
counter = 1
routerNumber = 1
routersToTest = []
for line in file:
line = line.rstrip('\n')
if line.startswith("/dev/tty"):
# Flash new build on routers
ipaddr = "192.168.2.1%d" % counter
counter += 1
if flash.flash(line, ipaddr):
routerNumber += 1
routersToTest.append(line)
else:
# For now, if a flash fails, you will need to reboot that router into uboot manually and run the script
# on that router again (or flash manually if you prefer).
print("Flashing failed on router with port " + line)
def __init__(self, ui, dbgio):
self.ui = ui
self.dbgio = dbgio
self.device = vendor.get_device(self.ui, soc_name)
# add the 8MiB SDRAM
self.device.insert(
soc.make_peripheral('sdram', 0xc0000000, 8 << 20, None,
'external sdram'))
self.dbgio.connect(self.device.cpu_info.name, 'swd')
self.cpu = cortexm.cortexm(self, ui, self.dbgio, self.device)
self.device.bind_cpu(self.cpu)
self.mem = mem.mem(self.cpu)
self.flash = flash.flash(flash_driver.sdrv(self.device), self.device,
self.mem)
gpio_drv = (gpio_driver.drv(self.device, gpio_cfg))
self.gpio = gpio.gpio(gpio_drv)
self.i2c1 = i2c.i2c(i2c_driver.bitbang(gpio_drv, 'PB8', 'PB9'))
self.i2c3 = i2c.i2c(i2c_driver.bitbang(gpio_drv, 'PH7', 'PH8'))
# setup the rtt client
ram = self.device.sram
self.rtt = rtt.rtt(self.cpu, mem.region('ram', ram.address, ram.size))
self.menu_root = (
('cpu', self.cpu.menu, 'cpu functions'),
('da', self.cpu.cmd_disassemble, cortexm.help_disassemble),
('debugger', self.dbgio.menu, 'debugger functions'),
('exit', self.cmd_exit),
('flash', self.flash.menu, 'flash functions'),
('go', self.cpu.cmd_go),
('gpio', self.gpio.menu, 'gpio functions'),
('halt', self.cpu.cmd_halt),
('help', self.ui.cmd_help),
('history', self.ui.cmd_history, cli.history_help),
('i2c1', self.i2c1.menu, 'i2c1 functions'),
('i2c3', self.i2c3.menu, 'i2c3 functions'),
('map', self.device.cmd_map),
('mem', self.mem.menu, 'memory functions'),
('program', self.flash.cmd_program, flash.help_program),
('regs', self.cmd_regs, soc.help_regs),
('rtt', self.rtt.menu, 'rtt client functions'),
('vtable', self.cpu.cmd_vtable),
)
self.ui.cli.set_root(self.menu_root)
self.set_prompt()
self.dbgio.cmd_info(self.ui, None)
def __init__(self, ui, dbgio):
self.ui = ui
self.dbgio = dbgio
self.device = vendor.get_device(self.ui, soc_name)
self.dbgio.connect(self.device.cpu_info.name, 'swd')
self.cpu = cortexm.cortexm(self, ui, self.dbgio, self.device)
self.device.bind_cpu(self.cpu)
self.mem = mem.mem(self.cpu)
self.flash = flash.flash(flash_driver.sdrv(self.device), self.device,
self.mem)
gpio_drv = (gpio_driver.drv(self.device, gpio_cfg))
self.gpio = gpio.gpio(gpio_drv)
self.i2c = i2c.i2c(i2c_driver.gpio(gpio_drv, 'PB6', 'PB9'))
self.dac = dac.cs43l22(self.i2c, 0x94, self.dac_reset)
# setup the rtt client
ram = self.device.sram
self.rtt = rtt.rtt(self.cpu, mem.region('ram', ram.address, ram.size))
# setup the gdb server
self.gdb = gdb.gdb(self.cpu)
self.menu_root = (
('cpu', self.cpu.menu, 'cpu functions'),
('da', self.cpu.cmd_disassemble, cortexm.help_disassemble),
('dac', self.dac.menu, 'dac functions'),
('debugger', self.dbgio.menu, 'debugger functions'),
('exit', self.cmd_exit),
('flash', self.flash.menu, 'flash functions'),
('gdb', self.gdb.run),
('go', self.cpu.cmd_go),
('gpio', self.gpio.menu, 'gpio functions'),
('halt', self.cpu.cmd_halt),
('help', self.ui.cmd_help),
('history', self.ui.cmd_history, cli.history_help),
('i2c', self.i2c.menu, 'i2c functions'),
('map', self.device.cmd_map),
('mem', self.mem.menu, 'memory functions'),
('program', self.flash.cmd_program, flash.help_program),
('regs', self.cmd_regs, soc.help_regs),
('rtt', self.rtt.menu, 'rtt client functions'),
('vtable', self.cpu.cmd_vtable),
)
self.ui.cli.set_root(self.menu_root)
self.set_prompt()
self.dbgio.cmd_info(self.ui, None)
def __init__(self, ui, dbgio):
self.ui = ui
self.dbgio = dbgio
self.device = vendor.get_device(self.ui, soc_name)
self.dbgio.connect(self.device.cpu_info.name, 'swd')
self.cpu = cortexm.cortexm(self, ui, self.dbgio, self.device)
self.device.bind_cpu(self.cpu)
self.mem = mem.mem(self.cpu)
self.flash = flash.flash(flash_driver.sdrv(self.device), self.device, self.mem)
gpio_drv = (gpio_driver.drv(self.device, gpio_cfg))
self.gpio = gpio.gpio(gpio_drv)
self.i2c = i2c.i2c(i2c_driver.gpio(gpio_drv, 'PB6', 'PB9'))
self.dac = dac.cs43l22(self.i2c, 0x94, self.dac_reset)
# setup the rtt client
ram = self.device.sram
self.rtt = rtt.rtt(self.cpu, mem.region('ram', ram.address, ram.size))
# setup the gdb server
self.gdb = gdb.gdb(self.cpu)
self.menu_root = (
('cpu', self.cpu.menu, 'cpu functions'),
('da', self.cpu.cmd_disassemble, cortexm.help_disassemble),
('dac', self.dac.menu, 'dac functions'),
('debugger', self.dbgio.menu, 'debugger functions'),
('exit', self.cmd_exit),
('flash', self.flash.menu, 'flash functions'),
('gdb', self.gdb.run),
('go', self.cpu.cmd_go),
('gpio', self.gpio.menu, 'gpio functions'),
('halt', self.cpu.cmd_halt),
('help', self.ui.cmd_help),
('history', self.ui.cmd_history, cli.history_help),
('i2c', self.i2c.menu, 'i2c functions'),
('map', self.device.cmd_map),
('mem', self.mem.menu, 'memory functions'),
('program', self.flash.cmd_program, flash.help_program),
('regs', self.cmd_regs, soc.help_regs),
('rtt', self.rtt.menu, 'rtt client functions'),
('vtable', self.cpu.cmd_vtable),
)
self.ui.cli.set_root(self.menu_root)
self.set_prompt()
self.dbgio.cmd_info(self.ui, None)
def gconnect():
# Validate state token
if request.args.get('state') != login_session['state']:
response = make_response(json.dumps('Invalid state parameter.'), 401)
response.headers['Content-Type'] = 'application/json'
return response
# Obtain authorization code, now compatible with Python3
request.get_data()
code = request.data.decode('utf-8')
try:
# Upgrade the authorization code into a credentials object
oauth_flow = flow_from_clientsecrets('client_secrets.json', scope='')
oauth_flow.redirect_uri = 'postmessage'
credentials = oauth_flow.step2_exchange(code)
except FlowExchangeError:
response = make_response(
json.dumps('Failed to upgrade the authorization code.'), 401)
response.headers['Content-Type'] = 'application/json'
return response
# Check that the access token is valid.
access_token = credentials.access_token
url = ('https://www.googleapis.com/oauth2/v1/tokeninfo?access_token=%s'
% access_token)
# Submit request, parse response - Python3 compatible
h = httplib2.Http()
response = h.request(url, 'GET')[1]
str_response = response.decode('utf-8')
result = json.loads(str_response)
# If there was an error in the access token info, abort.
if result.get('error') is not None:
response = make_response(json.dumps(result.get('error')), 500)
response.headers['Content-Type'] = 'application/json'
return response
# Verify that the access token is used for the intended user.
gplus_id = credentials.id_token['sub']
if result['user_id'] != gplus_id:
response = make_response(
json.dumps("Token's user ID doesn't match given user ID."), 401)
response.headers['Content-Type'] = 'application/json'
return response
# Verify that the access token is valid for this app.
if result['issued_to'] != CLIENT_ID:
response = make_response(
json.dumps("Token's client ID does not match app's."), 401)
response.headers['Content-Type'] = 'application/json'
return response
stored_access_token = login_session.get('access_token')
stored_gplus_id = login_session.get('gplus_id')
if stored_access_token is not None and gplus_id == stored_gplus_id:
response = make_response(json.dumps('Current user is already connected.'),
200)
response.headers['Content-Type'] = 'application/json'
return response
# Store the access token in the session for later use.
login_session['access_token'] = access_token
login_session['gplus_id'] = gplus_id
# Get user info
userinfo_url = "https://www.googleapis.com/oauth2/v1/userinfo"
params = {'access_token': access_token, 'alt': 'json'}
answer = requests.get(userinfo_url, params=params)
data = answer.json()
login_session['username'] = data['name']
login_session['picture'] = data['picture']
login_session['email'] = data['email']
# see if user exists, if it doesn't make a new one
user_id = getUserID(login_session['email'])
if not user_id:
user_id = createUser(login_session)
login_session['user_id'] = user_id
output = ''
output += '<h1>Welcome, '
output += login_session['username']
output += '!</h1>'
output += '<img src="'
output += login_session['picture']
output += ' " style = "width: 300px; height: 300px;border-radius: 150px;-webkit-border-radius: 150px;-moz-border-radius: 150px;"> '
flash("you are now logged in as %s" % login_session['username'])
return output
