def index(self, page=1, format='html'):
"""Retrieve a paginated list of uploaded packages.
Arguments:
page: The page of packages to get. Each page contains 10 packages.
"""
if format == 'json':
pager = Pager(int(page),
"/packages.json?page=%d",
Package.all().order('-updated'),
per_page=50)
return json.dumps({
"packages": [
handlers.request().url(action='show', id=package.name)
for package in pager.get_items()
],
"prev":
pager.prev_url,
"next":
pager.next_url,
"pages":
pager.page_count
})
else:
pager = Pager(int(page), "/packages?page=%d",
Package.all().order('-updated'))
title = 'All Packages'
if page != 1: title = 'Page %s | %s' % (page, title)
return handlers.render("packages/index",
packages=pager.get_items(),
pagination=pager.render_pagination(),
layout={'title': title})
def job_package():
# Log.info("请异步发送")
need_do = ''
orders = Order.get_working_orders()
for order in orders:
product = Product.lookup(order['p_id'])
exchange = Exchange.get_exchange(order['e_id'])
packages = Package.getPackageByName(order['package_id'])
for package in packages:
need_do = need_do+json.dumps({'port':product['port'],'bandwidth':order['bandwidth'],\
'status':order['status'],'port_name':product['port'], 'ipAddress':exchange['ipAddress'], \
'package_id':package['package_name']})
# Order.finish_order(order['_id'])
need_back = ''
orders = Order.get_back_orders()
for order in orders:
custom_time = order['custom_time']
product = Product.lookup(order['p_id'])
exchange = Exchange.look(order['e_id'])
packages = Package.getPackageByName(order['package_id'])
for package in packages:
need_back = need_back+json.dumps({'port':product['port'],'ex_bandwidth':order['bandwidth'],\
'status':order['status'],'port_name':product['port'], 'ipAddress':exchange['ipAddress'], \
'package_id':package['package_name']})
# Order.back_order(order['_id'])
print 'set_package_job end at ', datetime.datetime.now()
def job_package():
# Log.info("请异步发送")
need_do = ''
orders = Order.get_working_orders()
for order in orders:
product = Product.lookup(order['p_id'])
exchange = Exchange.get_exchange(order['e_id'])
packages = Package.getPackageByName(order['package_id'])
for package in packages:
need_do = need_do+json.dumps({'port':product['port'],'bandwidth':order['bandwidth'],\
'status':order['status'],'port_name':product['port'], 'ipAddress':exchange['ipAddress'], \
'package_id':package['package_name']})
# Order.finish_order(order['_id'])
need_back=''
orders = Order.get_back_orders()
for order in orders:
custom_time = order['custom_time']
product = Product.lookup(order['p_id'])
exchange = Exchange.look(order['e_id'])
packages = Package.getPackageByName(order['package_id'])
for package in packages:
need_back = need_back+json.dumps({'port':product['port'],'ex_bandwidth':order['bandwidth'],\
'status':order['status'],'port_name':product['port'], 'ipAddress':exchange['ipAddress'], \
'package_id':package['package_name']})
# Order.back_order(order['_id'])
print 'set_package_job end at ',datetime.datetime.now()
def index(self, page=1, format='html'):
"""Retrieve a paginated list of uploaded packages.
Arguments:
page: The page of packages to get. Each page contains 10 packages.
"""
if format == 'json':
pager = QueryPager(int(page), "/packages.json?page=%d",
Package.all().order('-updated'),
per_page=50)
return json.dumps({
"packages": [
handlers.request().url(action='show', id=package.name)
for package in pager.get_items()
],
"prev": pager.prev_url,
"next": pager.next_url,
"pages": pager.page_count
})
else:
pager = QueryPager(int(page), "/packages?page=%d",
Package.all().order('-updated'))
title = 'All Packages'
if page != 1: title = 'Page %s | %s' % (page, title)
return handlers.render("packages/index",
packages=pager.get_items(),
pagination=pager.render_pagination(),
layout={'title': title})
def post(self):
p = Package()
p._id = self.get_argument('package_name')
package = Package.lookup(p._id)
p.avail_timelong = int(self.get_argument('avail_timelong', package['avail_timelong']))
p.avail_begintime = int(self.get_argument("avail_begintime", package['avail_begintime']))
p.avail_endtime = int(self.get_argument("avail_endtime1", package['avail_endtime']))
#p.avail_begintime = datetime.datetime.strptime(avail_begintime+':00', "%H:%M")
#p.avail_endtime = datetime.datetime.strptime(avail_endtime+':00',"%H:%M")
'''
p.pname = self.get_argument('package_name')
p.avail_timelong = int(self.get_argument('avail_timelong'))
p.avail_begintime = datetime.datetime.strptime(self.get_argument("avail_begintime"), "%H:%M")
p.avail_endtime = datetime.datetime.strptime(self.get_argument("avail_endtime"), "%H:%M")
avail_beginhourstr = self.get_argument("avail_begintime", None)
nPos1 =avail_beginhourstr.index(':')
avail_beginhour = int(avail_beginhourstr[0:nPos1])
avail_endhourstr = self.get_argument("avail_endtime", None)
nPos2 =avail_endhourstr.index(':')
avail_endhour = int(avail_endhourstr[0:nPos2])
if avail_endhour <= avail_beginhour:
p.effective_length = avail_endhour+24 - avail_beginhour
else:
p.effective_length = avail_endhour - avail_beginhour
'''
p.is_weekday= int(self.get_argument("is_weekday", package['is_weekday']))
p.created_at = datetime.datetime.now()
Package.updatePackage(p)
self.redirect("/get_packages")
def post(self):
package_name = self.get_argument("package_name", None)
status = self.get_argument("status", None)
page = self.get_argument('page', 1)
page = page if page >= 1 else 1
count = self.get_argument('count', 10)
count = count if count >= 1 else 10
template_values = {}
if package_name is not None:
if status is not None and status != '':
packages = Package.getPackageByCondition(package_name, int(status))
template_values['status'] = int(status)
else:
print package_name
packages = Package.getPackageByName(package_name)
print packages
template_values['status'] = ''
else:
if status is not None and status != '':
packages = Package.getPackageByStatus(int(status))
template_values['status'] = int(status)
else:
packages = Package.getallPackages()
template_values['status'] = ''
#create a Paginator object
paginator = Paginator(packages, page, count, len(packages))
template_values['_id'] = package_name
template_values['paginator'] = paginator
self.render_template('/site/searchPackage.html', **template_values)
def post(self):
package_name = self.get_argument("package_name", None)
status = self.get_argument("status", None)
page = self.get_argument('page', 1)
page = page if page >= 1 else 1
count = self.get_argument('count', 10)
count = count if count >= 1 else 10
template_values = {}
if package_name is not None:
if status is not None and status != '':
packages = Package.getPackageByCondition(
package_name, int(status))
template_values['status'] = int(status)
else:
print package_name
packages = Package.getPackageByName(package_name)
print packages
template_values['status'] = ''
else:
if status is not None and status != '':
packages = Package.getPackageByStatus(int(status))
template_values['status'] = int(status)
else:
packages = Package.getallPackages()
template_values['status'] = ''
#create a Paginator object
paginator = Paginator(packages, page, count, len(packages))
template_values['_id'] = package_name
template_values['paginator'] = paginator
self.render_template('/site/searchPackage.html', **template_values)
def test_create_requires_uploader(self):
Package.new(name='owned-package',
uploaders=[self.normal_user('owner')]).put()
self.be_normal_oauth_user()
response = self.testapp.get(
'/packages/owned-package/versions/abcd/create.json', status=403)
self.assert_json_error(response)
def test_api_create_requires_uploader(self):
Package.new(name='owned-package',
uploaders=[self.normal_user('owner')]).put()
self.be_normal_oauth_user()
response = self.testapp.get(
'/api/packages/owned-package/versions/abcd/create', status=403)
self.assert_json_error(response)
def test_get_package_json_without_versions(self):
admin = self.admin_user()
Package.new(name='test-package', uploaders=[admin]).put()
response = self.testapp.get('/packages/test-package.json')
self.assertEqual(response.headers['Content-Type'], 'application/json')
self.assertEqual(json.loads(response.body), {
"name": "test-package",
"uploaders": [admin.email()],
"versions": []
})
def test_api_get_package_without_versions(self):
admin = self.admin_user()
Package.new(name='test-package', uploaders=[admin]).put()
self.be_normal_user()
response = self.testapp.get('/api/packages/test-package')
self.assertEqual(response.headers['Content-Type'], 'application/json')
result = json.loads(response.body)
self.assertEqual(result["name"], "test-package")
self.assertEqual(result["versions"], [])
self.assertEqual(result["latest"], None)
def test_api_get_package_without_versions(self):
admin = self.admin_user()
Package.new(name='test-package', uploaders=[admin]).put()
self.be_normal_user()
response = self.testapp.get('/api/packages/test-package')
self.assertEqual(response.headers['Content-Type'], 'application/json')
result = json.loads(response.body)
self.assertEqual(result["name"], "test-package")
self.assertEqual(result["versions"], [])
self.assertEqual(result["latest"], None)
def test_api_uploadership_is_case_insensitive(self):
self.be_normal_oauth_user('NAme')
self.post_package_version(name='new-package', version='0.0.1')
version = Package.get_by_key_name('new-package').latest_version
self.assertIsNotNone(version)
self.assertEqual(version.version, SemanticVersion('0.0.1'))
self.be_normal_oauth_user('naME')
self.post_package_version(name='new-package', version='0.0.2')
version = Package.get_by_key_name('new-package').latest_version
self.assertIsNotNone(version)
self.assertEqual(version.version, SemanticVersion('0.0.2'))
def test_uploadership_is_case_insensitive(self):
self.be_normal_oauth_user('NAme')
self.post_package_version(name='new-package', version='0.0.1')
version = Package.get_by_key_name('new-package').latest_version
self.assertIsNotNone(version)
self.assertEqual(version.version, SemanticVersion('0.0.1'))
self.be_normal_oauth_user('naME')
self.post_package_version(name='new-package', version='0.0.2')
version = Package.get_by_key_name('new-package').latest_version
self.assertIsNotNone(version)
self.assertEqual(version.version, SemanticVersion('0.0.2'))
def setUp(self):
super(PackageVersionsTest, self).setUp()
self.package = Package.new(
name='test-package',
uploaders=[self.admin_user(),
self.normal_user('other-uploader')])
self.package.put()
def setUp(self):
super(PackageVersionsTest, self).setUp()
self.package = Package.new(
name='test-package',
uploaders=[self.admin_user(),
self.normal_user('other-uploader')])
self.package.put()
def generate_feed(page=1):
feed = FeedGenerator()
feed.id("https://pub.dartlang.org/feed.atom")
feed.title("Pub Packages for Dart")
feed.link(href="https://pub.dartlang.org/", rel="alternate")
feed.link(href="https://pub.dartlang.org/feed.atom", rel="self")
feed.description("Last Updated Packages")
feed.author({"name": "Dart Team"})
i = 1
pager = QueryPager(int(page), "/feed.atom?page=%d",
Package.all().order('-updated'),
per_page=10)
for item in pager.get_items():
i += 1
entry = feed.add_entry()
for author in item.latest_version.pubspec.authors:
entry.author({"name": author[0]})
entry.title("v" + item.latest_version.pubspec.get("version") +\
" of " + item.name)
entry.link(link={"href": item.url, "rel": "alternate",
"title": item.name})
entry.id(
"https://pub.dartlang.org/packages/" + item.name + "#" +\
item.latest_version.pubspec.get("version"))
entry.description(
item.latest_version.pubspec
.get("description", "Not Available"))
readme = item.latest_version.readme
if not readme is None:
entry.content(item.latest_version.readme.render(), type='html')
else:
entry.content("<p>No README Found</p>", type='html')
return feed
def generate_feed(page=1):
feed = FeedGenerator()
feed.id("https://pub.dartlang.org/feed.atom")
feed.title("Pub Packages for Dart")
feed.link(href="https://pub.dartlang.org/", rel="alternate")
feed.link(href="https://pub.dartlang.org/feed.atom", rel="self")
feed.description("Last Updated Packages")
feed.author({"name": "Dart Team"})
i = 1
pager = QueryPager(int(page),
"/feed.atom?page=%d",
Package.all().order('-updated'),
per_page=10)
for item in pager.get_items():
i += 1
entry = feed.add_entry()
for author in item.latest_version.pubspec.authors:
entry.author({"name": author[0]})
entry.title("v" + item.latest_version.pubspec.get("version") +\
" of " + item.name)
entry.link(link={"href": "https://pub.dartlang.org/packages/" +\
item.name, "rel": "alternate", "title": item.name})
entry.id(uuid.uuid5(uuid.NAMESPACE_URL,
("https://pub.dartlang.org/packages/" + item.name + "#" +\
item.latest_version.pubspec.get("version")).encode('utf-8')).urn)
entry.description(
item.latest_version.pubspec.get("description",
"Not Available"))
readme = item.latest_version.readme_obj
if readme is not None:
entry.content(readme.render(), type='html')
else:
entry.content("<p>No README Found</p>", type='html')
return feed
def _get_result(self, resource_item):
"""Convert a Custom Search API result into a map of package metadata
that can be rendered.
If the result does not reference a valid package, return None.
Arguments:
resource_item: The API result. It is expected to be a map containing
a "link" key which will likely be a package URL.
"""
link = resource_item["link"]
match = PACKAGE_URL_PATTERN.match(link)
if not match:
logging.warning('could not parse search result URL "%s"' % link)
return None
package = Package.get_by_key_name(match.group(1))
if not package:
logging.warning('could not find search result package "%s"' %
match.group(1))
return None
return {
"name": package.name,
"version": package.latest_version.version,
"desc": package.ellipsized_description,
"url": "/packages/" + package.name,
"last_uploaded": package.latest_version.relative_created
}
def setUp(self):
super(PackageUploadersTest, self).setUp()
self.package = Package.new(
name='test-package',
uploaders=[self.normal_user('uploader1'),
self.normal_user('uploader2')])
self.package.put()
def test_api_get_package_with_versions(self):
self.be_admin_user()
self.create_package('test-package', '1.1.0')
self.create_package('test-package', '1.1.1')
self.create_package('test-package', '1.2.0')
self.be_normal_user()
package = Package.get_by_key_name('test-package')
response = self.testapp.get('/api/packages/test-package')
self.assertEqual(response.headers['Content-Type'], 'application/json')
self.assertEqual(json.loads(response.body), {
"name": "test-package",
"url": "http://localhost:80/api/packages/test-package",
"uploaders_url": "http://localhost:80/api/packages/test-package/" +
"uploaders",
"version_url": "http://localhost:80/api/packages/test-package/" +
"versions/{version}",
"new_version_url":
"http://localhost:80/api/packages/test-package/versions/new",
"downloads": 0,
"uploaders": [self.admin_user().email()],
"created": package.created.isoformat(),
"versions": [
self.package_version_dict("test-package", "1.1.0"),
self.package_version_dict("test-package", "1.1.1"),
self.package_version_dict("test-package", "1.2.0"),
],
"latest": self.package_version_dict("test-package", "1.2.0")
})
def test_has_version(self):
package = Package.new(name='test-package',
uploaders=[self.admin_user()])
package.put()
self.package_version(package, '1.2.3').put()
self.assertTrue(package.has_version('1.2.3'))
self.assertFalse(package.has_version('1.2.4'))
def list_all():
pkgs = Package.select()
pkgs = [{
'package': x.name,
'version': x.version,
'created': x.created_date,
} for x in pkgs]
return pkgs
def test_has_version(self):
package = Package.new(name='test-package',
uploaders=[self.admin_user()])
package.put()
self.package_version(package, '1.2.3').put()
self.assertTrue(package.has_version('1.2.3'))
self.assertFalse(package.has_version('1.2.4'))
def setUp(self):
super(PackageUploadersTest, self).setUp()
self.package = Package.new(name='test-package',
uploaders=[
self.normal_user('uploader1'),
self.normal_user('uploader2')
])
self.package.put()
def get(pkgname):
"""
:param pkgname:
:return: The filepath for the package.
"""
matching_packages = (Package.select().where(Package.name == pkgname))
return None if len(matching_packages) == 0 else matching_packages[0].path
def _compute_version_order(self, name):
"""Compute the sort order for all versions of a given package."""
versions = list(Package.get_by_key_name(name).version_set.run())
versions.sort(key=lambda version: version.version)
for i, version in enumerate(versions):
version.sort_order = i
with models.transaction():
for version in versions: version.put()
def has(pkgname) -> Optional[Package]:
"""
:param pkgname:
:return: The matching package, None if not found.
"""
matching_packages = (Package.select().where(Package.name == pkgname))
return None if len(matching_packages) == 0 else matching_packages[0]
def test_uploader_deletes_uploader(self):
self.be_normal_oauth_user('uploader1')
response = self.testapp.delete(
'/packages/test-package/uploaders/%s.json' %
self.normal_user('uploader1').email())
self.assert_json_success(response)
package = Package.get_by_key_name('test-package')
self.assertEquals(package.uploaders, [self.normal_user('uploader2')])
def _compute_version_order(self, name):
"""Compute the sort order for all versions of a given package."""
versions = list(Package.get_by_key_name(name).version_set.run())
versions.sort(key=lambda version: version.version)
for i, version in enumerate(versions):
version.sort_order = i
with models.transaction():
for version in versions:
version.put()
def load_packages(self):
packages = Package.get_by_request_id(self.req.id)
self.tbl_packages.setRowCount(len(packages))
for i, p in enumerate(packages):
self.tbl_packages.setItem(i, 0, QTableWidgetItem(str(p.uuid_pack)))
self.tbl_packages.setItem(
i, 1, QTableWidgetItem(str(p.downloaded and 'Si' or 'No')))
self.tbl_packages.setItem(i, 2, QTableWidgetItem(str(p.id)))
self.tbl_packages.itemClicked.connect(self.enable_buttons)
def test_delete_is_case_insensitive(self):
self.be_normal_oauth_user('uploader1')
response = self.testapp.delete(
'/api/packages/test-package/uploaders/' +
self.normal_user('UpLoAdEr1').email())
self.assert_json_success(response)
package = Package.get_by_key_name('test-package')
self.assertEquals(package.uploaders, [self.normal_user('uploader2')])
def test_uploader_deletes_uploader(self):
self.be_normal_oauth_user('uploader1')
response = self.testapp.delete(
'/packages/test-package/uploaders/%s.json' %
self.normal_user('uploader1').email())
self.assert_json_success(response)
package = Package.get_by_key_name('test-package')
self.assertEquals(
package.uploaders, [self.normal_user('uploader2')])
def test_delete_is_case_insensitive(self):
self.be_normal_oauth_user('uploader1')
response = self.testapp.delete(
'/api/packages/test-package/uploaders/' +
self.normal_user('UpLoAdEr1').email())
self.assert_json_success(response)
package = Package.get_by_key_name('test-package')
self.assertEquals(
package.uploaders, [self.normal_user('uploader2')])
def get(self):
page = self.get_argument('page', 1)
page = page if page >= 1 else 1
count = self.get_argument('count', 10)
count = count if count >= 1 else 10
packages = Package.getPackages()
paginator = Paginator(packages, page, count, len(packages))
template_values = {}
template_values['paginator'] = paginator
self.render_template('/site/searchPackage.html', **template_values)
def get(self):
page = self.get_argument('page', 1)
page = page if page >= 1 else 1
count = self.get_argument('count', 10)
count = count if count >= 1 else 10
packages = Package.getPackages()
paginator = Paginator(packages, page, count, len(packages))
template_values = {}
template_values['paginator'] = paginator
self.render_template('/site/searchPackage.html', **template_values)
def check_request(self):
req = self.get_selected_request()
print('Realizando verificación de: {}'.format(req.name))
has_package = len(Package.get_by_request_id(
req.id)) > 0 and True or False
if req.state not in ('iniciada', 'verificada'):
return
fiel = Fiel.find_by_id(req.fiel_id)
if not fiel:
print('La solicitud no tiene una Fiel Válida')
return
f = Certificates(fiel.cer_pem.encode('utf-8'),
fiel.key_pem.encode('utf-8'),
fiel.passphrase,
pem=True)
check = RequestCheck(f)
token = authenticate_request(f)
data = check.check_request(token, self.empresa.rfc, req.uuid_request)
print(data)
values = {
'state': 'verificada',
}
if data.get('cod_estatus'):
values['cod_estatus'] = data['cod_estatus']
if data.get('estado_solicitud'):
if ESTADOS_SAT.get(data['estado_solicitud']):
values['estado_solicitud'] = ESTADOS_SAT[
data['estado_solicitud']]
else:
values['estado_solicitud'] = data['estado_solicitud']
if data.get('codigo_estado_solicitud'):
values['codigo_estado_solicitud'] = data['codigo_estado_solicitud']
if data.get('numero_cfdis'):
values['numero_cfdis'] = int(data['numero_cfdis'])
if data.get('mensaje'):
values['mensaje'] = data['mensaje']
req.update(values)
if not has_package:
for paq in data.get('paquetes'):
p = Package(uuid_pack=paq, request_id=req.id, downloaded=False)
p.save_to_db()
self.load_empresa()
def test_uploader_creates_new_uploader(self):
self.be_normal_oauth_user('uploader1')
response = self.testapp.post('/packages/test-package/uploaders.json',
{'email': self.normal_user().email()})
self.assert_json_success(response)
package = Package.get_by_key_name('test-package')
self.assertEquals(package.uploaders, [
self.normal_user('uploader1'),
self.normal_user('uploader2'),
self.normal_user()
])
def test_uploader_creates_new_uploader(self):
self.be_normal_oauth_user('uploader1')
response = self.testapp.post('/packages/test-package/uploaders.json',
{'email': self.normal_user().email()})
self.assert_json_success(response)
package = Package.get_by_key_name('test-package')
self.assertEquals(package.uploaders, [
self.normal_user('uploader1'),
self.normal_user('uploader2'),
self.normal_user()
])
def index(self, page=1):
"""Retrieve a paginated list of uploaded packages.
Arguments:
page: The page of packages to get. Each page contains 10 packages.
"""
pager = Pager(int(page), "/packages?page=%d", Package.all().order("-updated"))
title = "All Packages"
if page != 1:
title = "Page %s | %s" % (page, title)
return handlers.render(
"packages/index", packages=pager.get_items(), pagination=pager.render_pagination(), layout={"title": title}
)
def get(self):
package_name = self.get_argument('package_name')
package = Package.getPackageByName(package_name)
page = self.get_argument('page', 1)
page = page if page >= 1 else 1
#get the document count param
count = self.get_argument('count', 10)
count = count if count >= 1 else 10
paginator = Paginator(package, page, count, len(package))
template_values = {}
template_values['paginator'] = paginator
template_values['next'] = self.get_argument('next', '/')
self.render_template('/site/updatePackage.html', **template_values)
def get(self):
package_name = self.get_argument('package_name')
package = Package.getPackageByName(package_name)
page = self.get_argument('page', 1)
page = page if page >= 1 else 1
#get the document count param
count = self.get_argument('count', 10)
count = count if count >= 1 else 10
paginator = Paginator(package, page, count, len(package))
template_values = {}
template_values['paginator'] = paginator
template_values['next'] = self.get_argument('next','/')
self.render_template('/site/updatePackage.html',**template_values)
def maybe_package(self):
"""Load the current package object.
This auto-detects the package name from the request parameters. If the
package doesn't exist, returns None.
"""
if self._package: return self._package
name = self._package_name
if name is None: return None
self._package = Package.get_by_key_name(name)
if self._package: return self._package
return None
def index(self, page=1):
"""Retrieve a paginated list of uploaded packages.
Arguments:
page: The page of packages to get. Each page contains 50 packages.
"""
pager = Pager(int(page), "/api/packages?page=%d",
Package.all().order('-updated'),
per_page=100)
return json.dumps({
"packages": [package.as_dict() for package in pager.get_items()],
"prev_url": pager.prev_url,
"next_url": pager.next_url,
"pages": pager.page_count
})
def index(self, page=1):
"""Retrieve a paginated list of uploaded packages.
Arguments:
page: The page of packages to get. Each page contains 50 packages.
"""
pager = QueryPager(int(page), "/api/packages?page=%d",
Package.all().order('-updated'),
per_page=100)
return json.dumps({
"packages": [package.as_dict() for package in pager.get_items()],
"prev_url": pager.prev_url,
"next_url": pager.next_url,
"pages": pager.page_count
})
def test_create_is_case_insensitive(self):
self.be_normal_oauth_user('uploader1')
response = self.testapp.post(
'/api/packages/test-package/uploaders',
{'email': self.normal_user('NAme').email()})
self.assert_json_success(response)
response = self.testapp.post(
'/api/packages/test-package/uploaders',
{'email': self.normal_user('naME').email()},
status=400)
self.assert_json_error(response)
package = Package.get_by_key_name('test-package')
self.assertEquals(package.uploaders, [
self.normal_user('uploader1'),
self.normal_user('uploader2'),
self.normal_user('NAme')
])
def test_create_is_case_insensitive(self):
self.be_normal_oauth_user('uploader1')
response = self.testapp.post(
'/api/packages/test-package/uploaders',
{'email': self.normal_user('NAme').email()})
self.assert_json_success(response)
response = self.testapp.post(
'/api/packages/test-package/uploaders',
{'email': self.normal_user('naME').email()},
status=400)
self.assert_json_error(response)
package = Package.get_by_key_name('test-package')
self.assertEquals(package.uploaders, [
self.normal_user('uploader1'),
self.normal_user('uploader2'),
self.normal_user('NAme')
])
def test_user_creates_new_package(self):
self.be_normal_oauth_user()
self.post_package_version(name='new-package', version='0.0.1')
package = Package.get_by_key_name('new-package')
self.assertIsNotNone(package)
self.assertEqual(package.name, 'new-package')
self.assertEqual(package.uploaders, [handlers.get_current_user()])
version = package.version_set.get()
self.assertIsNotNone(version)
self.assertEqual(version.version, SemanticVersion('0.0.1'))
self.assertEqual(version.package.name, 'new-package')
version = package.latest_version
self.assertIsNotNone(version)
self.assertEqual(version.version, SemanticVersion('0.0.1'))
self.assertEqual(version.package.name, 'new-package')
self.assertEqual(package.updated, version.created)
def test_reload_reloads_a_package_version(self):
self.be_admin_user()
self.post_package_version("1.2.3")
version = PackageVersion.get_by_name_and_version("test-package", "1.2.3")
version.libraries = ["wrong"]
version.put()
response = self.testapp.post("/packages/versions/reload", status=302)
self.assertEqual(response.headers["Location"], "http://localhost:80/admin#tab-packages")
self.run_deferred_tasks()
version = PackageVersion.get_by_name_and_version("test-package", "1.2.3")
self.assertEqual([], version.libraries)
# The latest_version of the parent package should also be updated
version = Package.get_by_key_name("test-package").latest_version
self.assertEqual([], version.libraries)
self.assert_package_updated_is_latest_version_created()
def test_admin_creates_new_package_with_json(self):
self.be_admin_oauth_user()
self.post_package_version_with_json(name="new-package", version="0.0.1")
package = Package.get_by_key_name("new-package")
self.assertIsNotNone(package)
self.assertEqual(package.name, "new-package")
self.assertEqual(package.uploaders, [handlers.get_current_user()])
version = package.version_set.get()
self.assertIsNotNone(version)
self.assertEqual(version.version, SemanticVersion("0.0.1"))
self.assertEqual(version.package.name, "new-package")
version = package.latest_version
self.assertIsNotNone(version)
self.assertEqual(version.version, SemanticVersion("0.0.1"))
self.assertEqual(version.package.name, "new-package")
self.assertEqual(package.updated, version.created)
def test_api_user_creates_new_package(self):
self.be_normal_oauth_user()
self.post_package_version(name='new-package', version='0.0.1')
package = Package.get_by_key_name('new-package')
self.assertIsNotNone(package)
self.assertEqual(package.name, 'new-package')
self.assertEqual(package.uploaders, [handlers.get_current_user()])
version = package.version_set.get()
self.assertIsNotNone(version)
self.assertEqual(version.version, SemanticVersion('0.0.1'))
self.assertEqual(version.package.name, 'new-package')
version = package.latest_version
self.assertIsNotNone(version)
self.assertEqual(version.version, SemanticVersion('0.0.1'))
self.assertEqual(version.package.name, 'new-package')
self.assertEqual(package.updated, version.created)
self.assertEqual('This is a README.', version.readme.text)
def test_description(self):
package = Package.new(name='test-package',
uploaders=[self.admin_user()])
package.put()
def get_description():
return Package.get_by_key_name(package.name).description
def set_latest_version(version, **additional_pubspec_fields):
version = self.package_version(
package, version, **additional_pubspec_fields)
package.latest_version = version
version.put()
package.put()
self.assertIsNone(get_description())
set_latest_version('1.2.3')
self.assertIsNone(get_description())
set_latest_version('1.2.4', description='some package')
self.assertEquals('some package', get_description())
def test_description(self):
package = Package.new(name='test-package',
uploaders=[self.admin_user()])
package.put()
def get_description():
return Package.get_by_key_name(package.name).description
def set_latest_version(version, **additional_pubspec_fields):
version = self.package_version(package, version,
**additional_pubspec_fields)
package.latest_version = version
version.put()
package.put()
self.assertIsNone(get_description())
set_latest_version('1.2.3')
self.assertIsNone(get_description())
set_latest_version('1.2.4', description='some package')
self.assertEquals('some package', get_description())
def test_api_get_package_with_versions(self):
self.be_admin_user()
self.create_package('test-package', '1.1.0')
self.create_package('test-package', '1.1.1')
self.create_package('test-package', '1.2.0')
self.be_normal_user()
package = Package.get_by_key_name('test-package')
response = self.testapp.get('/api/packages/test-package')
self.assertEqual(response.headers['Content-Type'], 'application/json')
self.assertEqual(
json.loads(response.body), {
"name":
"test-package",
"url":
"http://localhost:80/api/packages/test-package",
"uploaders_url":
"http://localhost:80/api/packages/test-package/" + "uploaders",
"version_url":
"http://localhost:80/api/packages/test-package/" +
"versions/{version}",
"new_version_url":
"http://localhost:80/api/packages/test-package/versions/new",
"downloads":
0,
"uploaders": [self.admin_user().email()],
"created":
package.created.isoformat(),
"versions": [
self.package_version_dict("test-package", "1.1.0"),
self.package_version_dict("test-package", "1.1.1"),
self.package_version_dict("test-package", "1.2.0"),
],
"latest":
self.package_version_dict("test-package", "1.2.0")
})
def notice_device_app(dev: Device, pkg, ver):
matching_devs = (Device.select().where(Device.serial == dev.serial))
# Device doesn't exist
if len(matching_devs) == 0:
dev.save()
else:
print("Updating device with info: ")
print(dev)
# Device exists
match = matching_devs[0]
match.imei = dev.imei
match.wifi_mac = dev.wifi_mac
match.ext_ip = dev.ext_ip
match.lan_ip = dev.lan_ip
match.last_noticed = datetime.datetime.now()
Device.update(
imei=dev.imei,
wifi_mac=dev.wifi_mac,
ext_ip=dev.ext_ip,
lan_ip=dev.lan_ip,
last_noticed=match.last_noticed).where(id == dev.id).execute()
# match.update()
dev = match
pkgs = Package.select().where(Package.name == pkg)
if len(pkgs) == 0:
package = Package()
package.name = pkg
package.version = ver
package.save()
else:
package = pkgs[0]
existing_devpacks = DevicePackage.select().where(
(DevicePackage.device == dev) & (DevicePackage.package == package))
if len(existing_devpacks) == 0:
DevicePackage.create(device=dev, package=package, version=ver)
else:
for dpk in existing_devpacks:
dpk.version = ver
DevicePackage.update(version=ver).where(id == dpk.id).execute()
return dev
def assert_package_updated_is_latest_version_created(self):
package = Package.get_by_key_name('test-package')
self.assertEqual(package.updated, package.latest_version.created)
def latest_version(self):
return Package.get_by_key_name('test-package').latest_version.version
