def post(self):
logger.info("Method {0} POST".format(self.__class__.__name__))
object = request.get_json()
url_ = object['domain']
user = object['user']
# TODO: Bcrypt Generate Password Hash
# pwd = bcrypt.generate_password_hash(object['pwd']).decode()
pwd = object['password']
try:
if current_user:
uid = Auth.query\
.filter(Auth.user == current_user).first()
uid = uid.userid
except ProgrammingError:
return make_response("User Not found", 401)
store = Storage(uid=uid,
domain=url_,
user_for_domain=user,
password=pwd)
store.save()
def put(self, id):
parsed_args = reqparse.parse_args()
sku = SKU.query.filter_by(name=parsed_args['sku']).first()
if not sku:
abort(404,
message="Product {} does not exists".format(
parsed_args['sku']))
storage = Storage.query.filter_by(id=id).first()
if not storage:
storage = Storage(id=id)
storage.stock = parsed_args['quantity']
storage.sku = sku
db.session.add(storage)
db.session.commit()
return storage, 201
def publish(filename):
if request.method == "POST":
storage = Storage(publish_name=filename, author=current_user)
db.session.add(storage)
db.session.commit()
return redirect(url_for('index'))
return render_template('user.html', user=user, filename=filename)
def storage_factory(backend_strategy):
if getattr(g, 'storage', None) is None:
g.storage = {}
if backend_strategy in g.storage:
return g.storage[backend_strategy]
storage_strategy = StorageModel.get_by_id(backend_strategy)
if storage_strategy.backend_type == 'local':
g.storage[backend_strategy] = LocalStorage(storage_strategy)
elif storage_strategy.backend_type == 'qiniu':
g.storage[backend_strategy] = QiniuStorage(storage_strategy)
return g.storage[backend_strategy]
def user(username):
user = User.query.filter_by(username=username).first_or_404()
if request.method == 'POST':
# check if the post request has the file part
if 'file' not in request.files:
flash('No file part')
return redirect(request.url)
file = request.files['file']
# if user does not select file, browser also
# submit an empty part without filename
if file.filename == '':
flash('No selected file')
return redirect(request.url)
if file and allowed_file(file.filename):
filename = file.filename
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
storage = Storage(name=filename, author=current_user)
db.session.add(storage)
db.session.commit()
return render_template('user.html', user=user, filename=filename)
return render_template('user.html', user=user)
def run_app(filename):
# Read the data from the input file
data = read_file(filename)
# Get the data separated
plateau, deployment, movements = process_data(data)
# Create a storage for the data
storage = Storage(plateau, deployment, movements)
# Create the rovers and display input data
print("---------------------------")
print(" INPUT ")
print("---------------------------")
ctrl.init(storage)
# Move the rovers
ctrl.run(storage)
# Print the output data
print("---------------------------")
print(" OUTPUT ")
print("---------------------------")
ctrl.print_positions()
class TestBase(TestCase):
"""Base class test to be inheritted by other tests"""
def create_app(self):
"""Create test instance of the application"""
config_name = 'testing'
app = create_app(config_name)
app.config['SECRET_KEY'] = 'sekrit!'
return app
def setUp(self):
self.test_store = Storage()
self.test_store.add_user('test', '*****@*****.**', 'test')
self.test_user = self.test_store.get_single_user(1)
self.test_store.add_shoppinglist(1, 'Holiday Shopping')
self.test_shoppinglist = self.test_store.get_shoppinglist(1, 1)
def tearDown(self):
self.test_store = None
self.test_user = None
self.test_shoppinglist = None
def setUp(self):
self.test_store = Storage()
self.test_store.add_user('test', '*****@*****.**', 'test')
self.test_user = self.test_store.get_single_user(1)
self.test_store.add_shoppinglist(1, 'Holiday Shopping')
self.test_shoppinglist = self.test_store.get_shoppinglist(1, 1)
def index():
if Group.query.count() == 0:
admin = Group(group_name='administrator')
db.session.add(admin)
student = Group(group_name='student')
db.session.add(student)
teacher = Group(group_name='teacher')
db.session.add(teacher)
professor = Group(group_name='professor')
db.session.add(professor)
staff = Group(group_name='staff')
db.session.add(staff)
if Storage.query.count() == 0:
T29 = Storage(location_name='T29 Storage',
available_time='9a.m.-12p.m.',
phone_number=13124242523)
T4 = Storage(location_name='T4 Storage',
available_time='9a.m.-12p.m.',
phone_number=13124242523)
T5 = Storage(location_name='T5 Storage',
available_time='9a.m.-12p.m.',
phone_number=13124242523)
T6 = Storage(location_name='T6 Storage',
available_time='9a.m.-12p.m.',
phone_number=13124242523)
T7 = Storage(location_name='T7 Storage',
available_time='9a.m.-12p.m.',
phone_number=13124242523)
T8 = Storage(location_name='T8 Storage',
available_time='9a.m.-12p.m.',
phone_number=13124242523)
db.session.add(T29)
db.session.add(T4)
db.session.add(T5)
db.session.add(T6)
db.session.add(T7)
db.session.add(T8)
if Category.query.count() == 0:
electronic = Category(name="electronic")
living_thing = Category(name="living_thing")
valuables = Category(name="valuables")
card = Category(name="card")
school_supplies = Category(name="school_supplies")
book = Category(name="book")
others = Category(name="others")
db.session.add(electronic)
db.session.add(living_thing)
db.session.add(valuables)
db.session.add(card)
db.session.add(school_supplies)
db.session.add(book)
db.session.add(others)
user_count = User.query.count()
found_count = Item.query.filter_by(status='found').count()
lost_count = Item.query.filter_by(status='lost').count()
success_count = Item.query.filter_by(status='success').count()
return render_template('index.html',
user_count=user_count,
found_count=found_count,
lost_count=lost_count,
success_count=success_count,
current_user=current_user)
def test_storage(self):
plateau = [4, 3]
deployment = {
1: [3, 4, 'N'],
2: [0, 2, 'W']
}
movement = {
1: 'LMRLMRRLL',
2: 'LMRRML'
}
storage = Storage(plateau, deployment, movement)
self.assertIsNotNone(storage.get_plateau())
self.assertIsNot(storage.get_plateau(), [])
self.assertEqual(len(storage.get_plateau()), 2)
self.assertIsNotNone(storage.get_deployment())
self.assertIsNotNone(storage.get_deployment().keys())
for key in storage.get_deployment().keys():
self.assertIsNot(storage.get_deployment()[key], [])
self.assertEqual(len(storage.get_deployment()[key]), 3)
cardinal_point = storage.get_deployment()[key][2]
self.assertIsNotNone(cardinal_point)
self.assertIn(cardinal_point, ('N', 'S', 'W', 'E'))
self.assertEqual(len(cardinal_point), 1)
self.assertIsNotNone(storage.get_movements())
self.assertIsNotNone(storage.get_movements().keys())
for key in storage.get_movements().keys():
self.assertNotEqual(storage.get_movements()[key], '')
self.assertIsInstance(storage.get_movements()[key], str)
for move in storage.get_movements()[key]:
self.assertIn(move, ('L', 'R', 'M'))