def get_urls(version=1):
api = Api(api_name='auth')
if version == 1:
api.register(User())
return api.urls
def test_top_level_include_schema_content(self):
api = Api()
note_resource = NoteResource()
user_resource = UserResource()
api.register(note_resource)
api.register(user_resource)
request = HttpRequest()
request.GET = {'fullschema': 'true'}
resp = api.top_level(request)
self.assertEqual(resp.status_code, 200)
content = json.loads(resp.content.decode('utf-8'))
content['notes']['schema'] = adjust_schema(content['notes']['schema'])
content['users']['schema'] = adjust_schema(content['users']['schema'])
dummy_request = HttpRequest()
dummy_request.method = 'GET'
notes_schema = adjust_schema(json.loads(note_resource.get_schema(dummy_request).content.decode('utf-8')))
user_schema = adjust_schema(json.loads(user_resource.get_schema(dummy_request).content.decode('utf-8')))
self.assertEqual(content['notes']['list_endpoint'], '/api/v1/notes/')
self.assertEqual(content['notes']['schema'], notes_schema)
self.assertEqual(content['users']['list_endpoint'], '/api/v1/users/')
self.assertEqual(content['users']['schema'], user_schema)
def test_unregister(self):
tastypie.available_apis = {}
api = Api()
api.register(NoteResource())
api.register(UserResource(), canonical=False)
self.assertEqual(sorted(api._registry.keys()), ["notes", "users"])
self.assertEqual(len(tastypie.available_apis), 1)
self.assertEqual(tastypie.available_apis["v1"]["class"], api)
self.assertEqual(tastypie.available_apis["v1"]["resources"], ["notes", "users"])
self.assertEqual(tastypie.available_apis["v1"]["representations"], {"NoteRepresentation": "notes"})
self.assertEqual(len(api._canonicals), 1)
api.unregister("users")
self.assertEqual(len(api._registry), 1)
self.assertEqual(sorted(api._registry.keys()), ["notes"])
self.assertEqual(len(api._canonicals), 1)
self.assertEqual(tastypie.available_apis["v1"]["class"], api)
self.assertEqual(tastypie.available_apis["v1"]["resources"], ["notes"])
self.assertEqual(tastypie.available_apis["v1"]["representations"], {"NoteRepresentation": "notes"})
api.unregister("notes")
self.assertEqual(len(api._registry), 0)
self.assertEqual(sorted(api._registry.keys()), [])
self.assertEqual(tastypie.available_apis["v1"]["class"], api)
self.assertEqual(tastypie.available_apis["v1"]["resources"], [])
self.assertEqual(tastypie.available_apis["v1"]["representations"], {})
api.unregister("users")
self.assertEqual(len(api._registry), 0)
self.assertEqual(sorted(api._registry.keys()), [])
self.assertEqual(tastypie.available_apis["v1"]["class"], api)
self.assertEqual(tastypie.available_apis["v1"]["resources"], [])
self.assertEqual(tastypie.available_apis["v1"]["representations"], {})
def test_canonical_resource_for(self):
tastypie.available_apis = {}
api = Api()
note_resource = NoteResource()
user_resource = UserResource()
api.register(note_resource)
api.register(user_resource)
self.assertEqual(len(api._canonicals), 2)
self.assertEqual(isinstance(api.canonical_resource_for("notes"), NoteResource), True)
api_2 = Api()
self.assertRaises(URLReverseError, tastypie._get_canonical_resource_name, api_2, NoteRepresentation)
self.assertEqual(tastypie._get_canonical_resource_name(api.api_name, NoteRepresentation), "notes")
self.assertEqual(tastypie._get_canonical_resource_name(api.api_name, NoteRepresentation()), "notes")
self.assertEqual(
tastypie._get_canonical_resource_name(api.api_name, note_resource.detail_representation), "notes"
)
self.assertEqual(tastypie._get_canonical_resource_name(api.api_name, UserRepresentation), "users")
self.assertEqual(tastypie._get_canonical_resource_name(api.api_name, UserRepresentation()), "users")
self.assertEqual(
tastypie._get_canonical_resource_name(api.api_name, user_resource.detail_representation), "users"
)
api.unregister(user_resource.resource_name)
self.assertRaises(NotRegistered, api.canonical_resource_for, "users")
def test_top_level_jsonp(self):
api = Api()
api.register(NoteResource())
api.register(UserResource())
request = HttpRequest()
request.META = {"HTTP_ACCEPT": "text/javascript"}
request.GET = {"callback": "foo"}
resp = api.top_level(request)
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp["content-type"].split(";")[0], "text/javascript")
self.assertEqual(
resp.content.decode("utf-8"),
'foo({"notes": {"list_endpoint": "/api/v1/notes/", "schema": "/api/v1/notes/schema/"}, "users": {"list_endpoint": "/api/v1/users/", "schema": "/api/v1/users/schema/"}})',
)
request = HttpRequest()
request.META = {"HTTP_ACCEPT": "text/javascript"}
request.GET = {"callback": ""}
try:
resp = api.top_level(request)
self.fail("Broken callback didn't fail!")
except BadRequest:
# Regression: We expect this, which is fine, but this used to
# be an import error.
pass
def get_urls(version=1):
api = Api(api_name='common')
if version == 1:
api.register(Country())
return api.urls
def test_top_level_include_schema_content(self):
api = Api()
note_resource = NoteResource()
user_resource = UserResource()
api.register(note_resource)
api.register(user_resource)
request = HttpRequest()
request.GET = {"fullschema": "true"}
resp = api.top_level(request)
self.assertEqual(resp.status_code, 200)
content = json.loads(resp.content.decode("utf-8"))
content["notes"]["schema"] = adjust_schema(content["notes"]["schema"])
content["users"]["schema"] = adjust_schema(content["users"]["schema"])
dummy_request = HttpRequest()
dummy_request.method = "GET"
notes_schema = adjust_schema(json.loads(note_resource.get_schema(dummy_request).content.decode("utf-8")))
user_schema = adjust_schema(json.loads(user_resource.get_schema(dummy_request).content.decode("utf-8")))
self.assertEqual(content["notes"]["list_endpoint"], "/api/v1/notes/")
self.assertEqual(content["notes"]["schema"], notes_schema)
self.assertEqual(content["users"]["list_endpoint"], "/api/v1/users/")
self.assertEqual(content["users"]["schema"], user_schema)
def test_custom_api_serializer(self):
"""Confirm that an Api can use a custom serializer"""
# Origin: https://github.com/django-tastypie/django-tastypie/pull/817
class JSONSerializer(Serializer):
formats = ('json', )
api = Api(serializer_class=JSONSerializer)
api.register(NoteResource())
request = HttpRequest()
request.META = {'HTTP_ACCEPT': 'text/javascript'}
resp = api.top_level(request)
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp['content-type'], 'application/json',
msg="Expected application/json response but received %s" % resp['content-type'])
request = HttpRequest()
request.META = {'HTTP_ACCEPT': 'application/xml'}
resp = api.top_level(request)
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp['content-type'], 'application/json',
msg="Expected application/json response but received %s" % resp['content-type'])
def named_api(api_name):
""" api_name is the version part of the api path
"""
new_api = Api(api_name=api_name)
for resource in resources.__all__:
new_api.register(getattr(resources, resource)())
return new_api
def get_api():
addata_api = Api(api_name='v1')
addata_api.register(LoginResource())
addata_api.register(URLRecordResource())
addata_api.register(FBAdResource())
addata_api.register(FBSponsoredResource())
addata_api.register(FBListingResource())
return addata_api
def get_api(): # create the naespaces for the applications api = Api(api_name='simpleapp') api.register(TypeResource()) api.register(ProductResource()) base_path_regex = r'^api/v1/' return base_path_regex,api
def test_top_level(self):
api = Api()
api.register(NoteResource())
api.register(UserResource())
request = HttpRequest()
resp = api.top_level(request)
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.content.decode('utf-8'), '{"notes": {"list_endpoint": "/api/v1/notes/", "schema": "/api/v1/notes/schema/"}, "users": {"list_endpoint": "/api/v1/users/", "schema": "/api/v1/users/schema/"}}')
def test_top_level(self):
api = Api()
api.register(NoteResource())
api.register(UserResource())
request = HttpRequest()
resp = api.top_level(request)
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.content, '{"notes": "/api/v1/notes/", "users": "/api/v1/users/"}')
def build_api_urls():
v1_api = Api(api_name='v1')
v1_api.register(VideoResource())
v1_api.register(CategoryResource())
return patterns(
'richard.videos.views',
(r'^api/', include(v1_api.urls)),
)
def resouce_autodiscover(api_name="v1", api_module_name="api"):
api = Api(api_name=api_name)
for app in settings.INSTALLED_APPS:
try:
resorce_api = import_module('%s.%s' % (app, api_module_name))
for resource_klass_name in resorce_api.__all__:
resource_klass = getattr(resorce_api, resource_klass_name)
api.register(resource_klass())
except:
continue
return api
def test_canonical_resource_for(self):
api = Api()
note_resource = NoteResource()
user_resource = UserResource()
api.register(note_resource)
api.register(user_resource)
self.assertEqual(len(api._canonicals), 2)
self.assertEqual(isinstance(api.canonical_resource_for('notes'), NoteResource), True)
api.unregister(user_resource._meta.resource_name)
self.assertRaises(NotRegistered, api.canonical_resource_for, 'users')
def test_jsonp_not_on_by_default(self):
api = Api()
api.register(NoteResource())
api.register(UserResource())
request = HttpRequest()
request.META = {'HTTP_ACCEPT': 'text/javascript'}
request.GET = {'callback': 'foo'}
resp = api.top_level(request)
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp['content-type'].split(';')[0], 'application/json')
self.assertFalse("foo" in resp.content.decode('utf-8'))
def resouce_autodiscover():
from django.conf import settings
from django.utils.importlib import import_module
v1_api = Api(api_name='v1')
for app in settings.INSTALLED_APPS:
try:
resorce_api = import_module('%s.api' % app)
for resource_klass_name in resorce_api.__all__:
resource_klass = getattr(resorce_api, resource_klass_name)
v1_api.register(resource_klass())
except:
continue
return v1_api
def test_top_level_jsonp(self):
api = Api()
api.register(NoteResource())
api.register(UserResource())
request = HttpRequest()
request.META = {"HTTP_ACCEPT": "text/javascript"}
request.GET = {"callback": "foo"}
resp = api.top_level(request)
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp["content-type"].split(";")[0], "text/javascript")
self.assertEqual(
resp.content,
'foo({"notes": {"list_endpoint": "/api/v1/notes/", "schema": "/api/v1/notes/schema/"}, "users": {"list_endpoint": "/api/v1/users/", "schema": "/api/v1/users/schema/"}})',
)
def test_urls(self):
api = Api()
api.register(NoteResource())
api.register(UserResource())
patterns = api.urls
self.assertEqual(len(patterns), 3)
self.assertEqual(sorted([pattern.name for pattern in patterns if hasattr(pattern, 'name')]), ['api_v1_top_level'])
self.assertEqual([[pattern.name for pattern in include.url_patterns if hasattr(pattern, 'name')] for include in patterns if hasattr(include, 'reverse_dict')], [['api_dispatch_list', 'api_get_schema', 'api_get_multiple', 'api_dispatch_detail'], ['api_dispatch_list', 'api_get_schema', 'api_get_multiple', 'api_dispatch_detail']])
api = Api(api_name='v2')
api.register(NoteResource())
api.register(UserResource())
patterns = api.urls
self.assertEqual(len(patterns), 3)
self.assertEqual(sorted([pattern.name for pattern in patterns if hasattr(pattern, 'name')]), ['api_v2_top_level'])
self.assertEqual([[pattern.name for pattern in include.url_patterns if hasattr(pattern, 'name')] for include in patterns if hasattr(include, 'reverse_dict')], [['api_dispatch_list', 'api_get_schema', 'api_get_multiple', 'api_dispatch_detail'], ['api_dispatch_list', 'api_get_schema', 'api_get_multiple', 'api_dispatch_detail']])
def test_unregister(self):
api = Api()
api.register(NoteResource())
api.register(UserResource(), canonical=False)
self.assertEqual(sorted(api._registry.keys()), ['notes', 'users'])
self.assertEqual(len(api._canonicals), 1)
api.unregister('users')
self.assertEqual(len(api._registry), 1)
self.assertEqual(sorted(api._registry.keys()), ['notes'])
self.assertEqual(len(api._canonicals), 1)
api.unregister('notes')
self.assertEqual(len(api._registry), 0)
self.assertEqual(sorted(api._registry.keys()), [])
api.unregister('users')
self.assertEqual(len(api._registry), 0)
self.assertEqual(sorted(api._registry.keys()), [])
def test_urls(self):
api = Api()
api.register(NoteResource())
api.register(UserResource())
patterns = api.urls
self.assertEqual(len(patterns), 3)
self.assertEqual(
sorted([pattern.name for pattern in patterns if hasattr(pattern, "name")]), ["api_v1_top_level"]
)
self.assertEqual(
[
[pattern.name for pattern in include.url_patterns if hasattr(pattern, "name")]
for include in patterns
if hasattr(include, "reverse_dict")
],
[
["api_dispatch_list", "api_get_schema", "api_get_multiple", "api_dispatch_detail"],
["api_dispatch_list", "api_get_schema", "api_get_multiple", "api_dispatch_detail"],
],
)
api = Api(api_name="v2")
api.register(NoteResource())
api.register(UserResource())
patterns = api.urls
self.assertEqual(len(patterns), 3)
self.assertEqual(
sorted([pattern.name for pattern in patterns if hasattr(pattern, "name")]), ["api_v2_top_level"]
)
self.assertEqual(
[
[pattern.name for pattern in include.url_patterns if hasattr(pattern, "name")]
for include in patterns
if hasattr(include, "reverse_dict")
],
[
["api_dispatch_list", "api_get_schema", "api_get_multiple", "api_dispatch_detail"],
["api_dispatch_list", "api_get_schema", "api_get_multiple", "api_dispatch_detail"],
],
)
class Api:
def __init__(self, resources):
self.tastypieApi = TastypieApi(api_name='resources')
self.dummy_resources = []
self.resources = {}
for resource_class in resources:
resource = resource_class()
self.resources[resource._meta.resource_name] = resource
self.tastypieApi.register(resource)
@property
def urls(self):
from django.conf.urls.defaults import url, patterns
from dummy import DummyResource
pattern_list = []
for resource_name, resource in self.resources.items():
if resource_name in self.dummy_resources:
pattern_list.append(
(r"^resources/%s/(\d*)/?$" % resource_name, DummyResource.get_view(resource)))
urls = patterns("",*pattern_list)
urls += self.tastypieApi.urls
return urls
def get_resource_list_uri(self, resource_name):
return self.resources[resource_name].get_resource_list_uri()
def get_resource_example_data(self, resource_name, method):
return self.resources[resource_name].get_example_data(method)
def resource_allows_method(self, resource_name, method):
return method.lower() in self.resources[resource_name]._meta.allowed_methods
def dehydrate(self,request, resource_name, obj):
resource = self.resources[resource_name]
bundle = resource.build_bundle(obj=obj, request=request)
bundle = resource.full_dehydrate(bundle)
return bundle.data
def test_top_level_jsonp(self):
api = Api()
api.register(NoteResource())
api.register(UserResource())
request = HttpRequest()
request.META = {'HTTP_ACCEPT': 'text/javascript'}
request.GET = {'callback': 'foo'}
resp = api.top_level(request)
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp['content-type'].split(';')[0], 'text/javascript')
self.assertEqual(resp.content.decode('utf-8'), 'foo({"notes": {"list_endpoint": "/api/v1/notes/", "schema": "/api/v1/notes/schema/"}, "users": {"list_endpoint": "/api/v1/users/", "schema": "/api/v1/users/schema/"}})')
request = HttpRequest()
request.META = {'HTTP_ACCEPT': 'text/javascript'}
request.GET = {'callback': ''}
# Regression: We expect this, which is fine, but this used to
# be an import error.
with self.assertRaises(BadRequest):
api.top_level(request)
def api_factory():
API_VERSION = 'v1'
pootle_api = Api(api_name=API_VERSION)
pootle_api.register(LanguageResource())
pootle_api.register(ProjectResource())
pootle_api.register(TranslationProjectResource())
return pootle_api
def test_global_registry(self):
api = Api()
self.assertEqual(len(api._registry), 0)
api.register(NoteResource())
self.assertEqual(len(api._registry), 1)
self.assertEqual(sorted(api._registry.keys()), ['notes'])
api.register(UserResource())
self.assertEqual(len(api._registry), 2)
self.assertEqual(sorted(api._registry.keys()), ['notes', 'users'])
api.register(UserResource())
self.assertEqual(len(api._registry), 2)
self.assertEqual(sorted(api._registry.keys()), ['notes', 'users'])
self.assertEqual(len(api._canonicals), 2)
api.register(UserResource(), canonical=False)
self.assertEqual(len(api._registry), 2)
self.assertEqual(sorted(api._registry.keys()), ['notes', 'users'])
self.assertEqual(len(api._canonicals), 2)
def test_register(self):
api = Api()
self.assertEqual(len(api._registry), 0)
api.register(NoteResource())
self.assertEqual(len(api._registry), 1)
self.assertEqual(sorted(api._registry.keys()), ["notes"])
api.register(UserResource())
self.assertEqual(len(api._registry), 2)
self.assertEqual(sorted(api._registry.keys()), ["notes", "users"])
api.register(UserResource())
self.assertEqual(len(api._registry), 2)
self.assertEqual(sorted(api._registry.keys()), ["notes", "users"])
self.assertEqual(len(api._canonicals), 2)
api.register(UserResource(), canonical=False)
self.assertEqual(len(api._registry), 2)
self.assertEqual(sorted(api._registry.keys()), ["notes", "users"])
self.assertEqual(len(api._canonicals), 2)
def test_register(self):
# NOTE: these have all been registered in core.tests.api_urls
api = Api()
self.assertEqual(len(api._registry), 0)
api.register(NoteResource())
self.assertEqual(len(api._registry), 1)
self.assertEqual(sorted(api._registry.keys()), ['notes'])
api.register(UserResource())
self.assertEqual(len(api._registry), 2)
self.assertEqual(sorted(api._registry.keys()), ['notes', 'users'])
api.register(UserResource())
self.assertEqual(len(api._registry), 2)
self.assertEqual(sorted(api._registry.keys()), ['notes', 'users'])
self.assertEqual(len(api._canonicals), 2)
api.register(UserResource(), canonical=False)
self.assertEqual(len(api._registry), 2)
self.assertEqual(sorted(api._registry.keys()), ['notes', 'users'])
self.assertEqual(len(api._canonicals), 2)
def test_register(self):
# NOTE: these have all been registered in core.tests.api_urls
api = Api()
self.assertEqual(len(api._registry), 0)
api.register(NoteResource())
self.assertEqual(len(api._registry), 1)
self.assertEqual(sorted(api._registry.keys()), ["notes"])
api.register(UserResource())
self.assertEqual(len(api._registry), 2)
self.assertEqual(sorted(api._registry.keys()), ["notes", "users"])
api.register(UserResource())
self.assertEqual(len(api._registry), 2)
self.assertEqual(sorted(api._registry.keys()), ["notes", "users"])
self.assertEqual(len(api._canonicals), 2)
api.register(UserResource(), canonical=False)
self.assertEqual(len(api._registry), 2)
self.assertEqual(sorted(api._registry.keys()), ["notes", "users"])
self.assertEqual(len(api._canonicals), 2)
self.assertRaises(ValueError, api.register, NoteResource)
class FreeAdminSite(object):
def __init__(self):
self._registry = {}
self.v1_api = Api(api_name='v1.0')
def register(self, model_or_iterable, admin_class=None,
freeadmin=None, **options):
"""
Registers the given model(s) with the given admin class.
The model(s) should be Model classes, not instances.
If an admin class isn't given, it will use BaseFreeAdmin (default
admin options). If keyword arguments are given they'll be applied
as options to the admin class.
"""
if not admin_class:
admin_class = BaseFreeAdmin
if isinstance(model_or_iterable, ModelBase):
model_or_iterable = [model_or_iterable]
admins = []
if model_or_iterable is None:
admin_obj = admin_class(c=freeadmin, admin=self)
self._registry[admin_obj] = admin_obj
else:
for model in model_or_iterable:
if model._meta.abstract:
log.warn("Model %r is abstract and thus cannot be registered",
model)
return None
if model in self._registry:
log.debug("Model %r already registered, overwriting...", model)
# If we got **options then dynamically construct a subclass of
# admin_class with those **options.
if options:
# For reasons I don't quite understand, without a __module__
# the created class appears to "live" in the wrong place,
# which causes issues later on.
options['__module__'] = __name__
admin_class = type("%sAdmin" % model.__name__,
(admin_class, ),
options)
# Instantiate the admin class to save in the registry
admin_obj = admin_class(c=freeadmin, model=model, admin=self)
self._registry[model] = admin_obj
model.add_to_class('_admin', admin_obj)
admins.append(admin_obj)
return admins
def unregister(self, model_or_iterable):
"""
Unregisters the given model(s).
If a model isn't already registered, this will raise NotRegistered.
"""
if isinstance(model_or_iterable, ModelBase):
model_or_iterable = [model_or_iterable]
for model in model_or_iterable:
if model not in self._registry:
raise NotRegistered('The model %s is not registered' % (
model.__name__,
))
del self._registry[model]
def has_permission(self, request):
"""
Returns True if the given HttpRequest has permission to view
*at least one* page in the admin site.
"""
return request.user.is_active and request.user.is_staff
def admin_view(self, view, cacheable=False):
"""
Decorator to create an admin view attached to this ``AdminSite``. This
wraps the view and provides permission checking by calling
``self.has_permission``.
You'll want to use this from within ``AdminSite.get_urls()``:
class MyAdminSite(AdminSite):
def get_urls(self):
from django.conf.urls import patterns, url
urls = super(MyAdminSite, self).get_urls()
urls += patterns('',
url(r'^my_view/$', self.admin_view(some_view))
)
return urls
By default, admin_views are marked non-cacheable using the
``never_cache`` decorator. If the view can be safely cached, set
cacheable=True.
"""
def inner(request, *args, **kwargs):
if not self.has_permission(request):
if request.path == reverse('account_logout'):
index_path = reverse('index', current_app=self.name)
return HttpResponseRedirect(index_path)
return self.login(request)
return view(request, *args, **kwargs)
if not cacheable:
inner = never_cache(inner)
# We add csrf_protect here so this function can be used as a utility
# function for any view, without having to repeat 'csrf_protect'.
if not getattr(view, 'csrf_exempt', False):
inner = csrf_protect(inner)
return update_wrapper(inner, view)
def get_urls(self):
from freenasUI.freeadmin.api.resources import SnapshotResource
self.v1_api.register(SnapshotResource())
def wrap(view, cacheable=False):
def wrapper(*args, **kwargs):
return self.admin_view(view, cacheable)(*args, **kwargs)
return update_wrapper(wrapper, view)
# Admin-site-wide views.
urlpatterns = patterns('',
url(r'^$',
wrap(self.adminInterface),
name='index'),
url(r'^api/',
include(self.v1_api.urls)),
url(r'^menu\.json/$',
wrap(self.menu),
name="freeadmin_menu"),
url(r'^alert/status/$',
wrap(self.alert_status),
name="freeadmin_alert_status"),
url(r'^alert/dismiss/$',
wrap(self.alert_dismiss),
name="freeadmin_alert_dismiss"),
url(r'^alert/$',
wrap(self.alert_detail),
name="freeadmin_alert_detail"),
)
# Add in each model's views.
for model_admin in self._registry.itervalues():
urlpatterns += patterns('',
url(r'^%s/%s/' % (
model_admin.app_label,
model_admin.module_name,
),
include(model_admin.urls))
)
return urlpatterns
@property
def urls(self):
return self.get_urls()
@never_cache
def adminInterface(self, request):
from freenasUI.network.models import GlobalConfiguration
from freenasUI.system.models import Advanced
try:
console = Advanced.objects.all().order_by('-id')[0].adv_consolemsg
except:
console = False
try:
hostname = GlobalConfiguration.objects.order_by(
'-id')[0].gc_hostname
except:
hostname = None
sw_version = get_sw_version()
return render(request, 'freeadmin/index.html', {
'consolemsg': console,
'hostname': hostname,
'sw_name': get_sw_name(),
'sw_version': sw_version,
'cache_hash': hashlib.md5(sw_version).hexdigest(),
})
@never_cache
def menu(self, request):
from freenasUI.freeadmin.navtree import navtree
try:
navtree.generate(request)
final = navtree.dijitTree(request.user)
json = simplejson.dumps(final)
except Exception, e:
log.debug("Fatal error while generating the tree json: %s", e)
json = ""
return HttpResponse(json, mimetype="application/json")
from django.conf.urls import patterns, include, url
# Uncomment the next two lines to enable the admin:
from django.contrib import admin
admin.autodiscover()
# tastypie restful stuff
from SiteConf.resources import UserResource, DiseaseTagResource, GeneResource, HVPTransactionResource, OrgSiteResource, UploadResource
from tastypie.api import Api
from tastypie.serializers import Serializer
# version 1.0 of tastypie rest api
v1_api = Api(api_name='v1')
v1_api.register(UserResource())
v1_api.register(DiseaseTagResource())
v1_api.register(GeneResource())
v1_api.register(HVPTransactionResource())
v1_api.register(OrgSiteResource())
v1_api.register(UploadResource())
v1_api.serializer = Serializer(formats=['json'])
urlpatterns = patterns('',
# Examples:
# url(r'^$', 'SiteConf.views.home', name='home'),
# url(r'^SiteConf/', include('SiteConf.foo.urls')),
# Uncomment the admin/doc line below to enable admin documentation:
url(r'^admin/doc/', include('django.contrib.admindocs.urls')),
# Uncomment the next line to enable the admin:
url(r'^admin/', include(admin.site.urls)),
from crits.emails.api import EmailResource
from crits.events.api import EventResource
from crits.exploits.api import ExploitResource
from crits.indicators.api import IndicatorResource, IndicatorActivityResource
from crits.ips.api import IPResource
from crits.pcaps.api import PCAPResource
from crits.raw_data.api import RawDataResource
from crits.samples.api import SampleResource
from crits.screenshots.api import ScreenshotResource
from crits.services.api import ServiceResource
from crits.signatures.api import SignatureResource
from crits.targets.api import TargetResource
from crits.vocabulary.api import VocabResource
v1_api = Api(api_name='v1')
v1_api.register(ActorResource())
v1_api.register(ActorIdentifierResource())
v1_api.register(BackdoorResource())
v1_api.register(CampaignResource())
v1_api.register(CertificateResource())
v1_api.register(CommentResource())
v1_api.register(DomainResource())
v1_api.register(EmailResource())
v1_api.register(EventResource())
v1_api.register(ExploitResource())
v1_api.register(IndicatorResource())
v1_api.register(IndicatorActivityResource())
v1_api.register(IPResource())
v1_api.register(PCAPResource())
v1_api.register(RawDataResource())
v1_api.register(SampleResource())
# -*- coding: utf-8 -*-
from django.conf.urls import include, url
from tastypie.api import Api
from pipeline.contrib.web.webresource.resource import (
PipelineTemplateResource, ComponentModelResource, PipelineInstanceResource,
TemplateSchemeResource)
from pipeline.contrib.web import urls_v1, urls_web
from pipeline.components import urls
v1_api = Api(api_name='v1')
v1_api.register(PipelineTemplateResource())
v1_api.register(ComponentModelResource())
v1_api.register(PipelineInstanceResource())
v1_api.register(TemplateSchemeResource())
urlpatterns = [
url(r'^', include(urls_web)),
url(r'^api/', include(v1_api.urls)),
url(r'^api/v1/', include(urls_v1)),
url(r'^', include(urls)),
]
__author__ = 'wangqiushi'
from django.conf.urls import patterns, url, include
from tastypie.api import Api
from yottaweb.apps.dashboard.resources import DashboardResource
version_api = Api(api_name='v0')
version_api.register(DashboardResource())
urlpatterns = patterns(
'yottaweb.apps.dashboard.views', (r'^dashboard/$', 'dashboard_group'),
(r'^dashboard/login/(.+)/(.+)/(.+)/$', 'dashboard_group_login'),
(r'^dashboard/(?P<did>[\w\d_]+)/(?P<tid>[\w\d_]+)/$', 'dashboard_detail'),
(r'^api/', include(version_api.urls)))
from django.conf.urls import include, url
from tastypie.api import Api
from content_gfk.api.resources import NoteResource, QuoteResource, \
RatingResource, DefinitionResource
api = Api(api_name='v1')
api.register(NoteResource())
api.register(QuoteResource())
api.register(RatingResource())
api.register(DefinitionResource())
urlpatterns = api.urls
# oppia/urls.py from django.conf import settings from django.conf.urls import patterns, include, url from django.views.generic import TemplateView from oppia.api.resources import TrackerResource, CourseResource, ScheduleResource, TagResource, ScorecardResource from oppia.api.resources import PointsResource, AwardsResource, BadgesResource, RegisterResource, UserResource from oppia.quiz.api.resources import QuizResource, QuizPropsResource, QuestionResource from oppia.quiz.api.resources import QuizQuestionResource, ResponseResource, QuizAttemptResource from tastypie.api import Api v1_api = Api(api_name='v1') v1_api.register(TrackerResource()) v1_api.register(CourseResource()) v1_api.register(ScheduleResource()) v1_api.register(TagResource()) v1_api.register(ScorecardResource()) v1_api.register(PointsResource()) v1_api.register(AwardsResource()) v1_api.register(BadgesResource()) v1_api.register(UserResource()) v1_api.register(RegisterResource()) v1_api.register(QuizResource()) v1_api.register(QuizPropsResource()) v1_api.register(QuestionResource()) v1_api.register(QuizQuestionResource()) v1_api.register(ResponseResource()) v1_api.register(QuizAttemptResource())
from django.conf.urls import include, patterns, url
from django.views.generic import TemplateView
from tastypie.api import Api
from api import DistrictResource, LanguageResource, MediatorResource, NonNegotiableResource, PartnerResource, PersonAdoptVideoResource, PersonGroupResource, PersonResource, ScreeningResource, VideoResource, VillageResource, TopicResource, StateResource, BlockResource
from views import coco_v2, debug, login, logout, record_full_download_time, reset_database_check
v1_api = Api(api_name='v2')
v1_api.register(DistrictResource())
v1_api.register(LanguageResource())
v1_api.register(PartnerResource())
v1_api.register(VillageResource())
v1_api.register(StateResource())
v1_api.register(BlockResource())
v1_api.register(MediatorResource())
v1_api.register(PersonAdoptVideoResource())
v1_api.register(PersonResource())
v1_api.register(PersonGroupResource())
v1_api.register(ScreeningResource())
v1_api.register(VideoResource())
v1_api.register(TopicResource())
v1_api.register(NonNegotiableResource())
urlpatterns = patterns(
'',
(r'^api/', include(v1_api.urls)),
(r'^login/', login),
(r'^logout/', logout),
(r'^debug/', debug),
from django.conf.urls import include, url
from tastypie.api import Api
from apps.forum import views
from apps.forum.resource import ForumResource
api = Api('forum')
api.register(ForumResource())
urlpatterns = [
url(r'^$', views.HomeView.as_view(), name='home'),
]
face = models.Face.objects.get(pk=bundle.data["id"])
return face.public_update({
"tags": tags[:-2],
"source": bundle.data.get("source", "")
})
def obj_create(self, bundle, request=None, **kwargs):
form = forms.CreateFace(bundle.data)
if form.is_valid():
return models.Face.submit(**form.cleaned_data)
else:
raise BadRequest("I just don't know what went wrong")
API.register(FaceResource())
class TagResource(ModelResource):
class Meta:
queryset = Tag.objects.all()
include_resource_uri = False
max_limit = 10000
allowed_methods = ['get']
fields = ['name']
filtering = {"name": ["contains", "startswith"]}
API.register(TagResource())
nutrition_api_views)
from wger.nutrition.sitemap import NutritionSitemap
from wger.utils.generic_views import (TextTemplateView, WebappManifestView)
from wger.weight.api import (resources as weight_api, views as
weight_api_views)
admin.autodiscover()
#
# REST API
#
# /api/v1 - tastypie - deprecated
v1_api = Api(api_name='v1')
v1_api.register(exercises_api.ExerciseCategoryResource())
v1_api.register(exercises_api.ExerciseCommentResource())
v1_api.register(exercises_api.ExerciseImageResource())
v1_api.register(exercises_api.ExerciseResource())
v1_api.register(exercises_api.MuscleResource())
v1_api.register(exercises_api.EquipmentResource())
v1_api.register(nutrition_api.IngredientResource())
v1_api.register(nutrition_api.WeightUnitResource())
v1_api.register(nutrition_api.NutritionPlanResource())
v1_api.register(nutrition_api.MealResource())
v1_api.register(nutrition_api.MealItemResource())
v1_api.register(nutrition_api.IngredientToWeightUnit())
v1_api.register(manager_api.WorkoutResource())
v1_api.register(manager_api.ScheduleResource())
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#########################################################################
from tastypie.api import Api
from .api import TagResource, TopicCategoryResource, ProfileResource, \
GroupResource, RegionResource, OwnersResource, ThesaurusKeywordResource
from .resourcebase_api import LayerResource, MapResource, DocumentResource, \
ResourceBaseResource, FeaturedResourceBaseResource
api = Api(api_name='api')
api.register(LayerResource())
api.register(MapResource())
api.register(DocumentResource())
api.register(ProfileResource())
api.register(ResourceBaseResource())
api.register(TagResource())
api.register(RegionResource())
api.register(TopicCategoryResource())
api.register(GroupResource())
api.register(FeaturedResourceBaseResource())
api.register(OwnersResource())
api.register(ThesaurusKeywordResource())
from django.conf.urls import url, include
from django.conf.urls.static import static
from django.conf import settings
from django.views.generic import TemplateView
from tastypie.api import Api
from .api.resources import TaskResource, UserResource, MessageResource, FileResource, BugReportResource, ChatResource
v1_api = Api(api_name='v1')
v1_api.register(UserResource())
v1_api.register(TaskResource())
v1_api.register(MessageResource())
v1_api.register(ChatResource())
v1_api.register(FileResource())
v1_api.register(BugReportResource())
urlpatterns = []
if settings.DEBUG:
if settings.MEDIA_ROOT:
urlpatterns += static(settings.MEDIA_URL,
document_root=settings.MEDIA_ROOT)
from tastypie.resources import ModelResource
from tastypie.api import Api
from oookbook.models import Book
from django.contrib.auth.models import User
class BookResource(ModelResource):
class Meta:
queryset = Book.objects.all()
resource_name = 'book'
class UserResource(ModelResource):
class Meta:
queryset = User.objects.all()
resource_name = 'user'
fields = ['first_name', 'last_name', 'username']
v1_api = Api(api_name='v1')
v1_api.register(BookResource())
v1_api.register(UserResource())
from tastypie.api import Api
from basic.api.resources import NoteResource, UserResource, BustedResource,\
CachedUserResource, PublicCachedUserResource, PrivateCachedUserResource,\
CacheDisabledUserResource, SlugBasedNoteResource, SessionUserResource
api = Api(api_name='v1')
api.register(NoteResource(), canonical=True)
api.register(UserResource(), canonical=True)
api.register(CachedUserResource(), canonical=True)
api.register(CacheDisabledUserResource(), canonical=True)
api.register(PublicCachedUserResource(), canonical=True)
api.register(PrivateCachedUserResource(), canonical=True)
v2_api = Api(api_name='v2')
v2_api.register(BustedResource(), canonical=True)
v2_api.register(SlugBasedNoteResource())
v2_api.register(SessionUserResource())
urlpatterns = v2_api.urls + api.urls
from dojo.jira_link.urls import urlpatterns as jira_urls
from dojo.trello_link.urls import urlpatterns as trello_urls
from dojo.tool_type.urls import urlpatterns as tool_type_urls
from dojo.tool_config.urls import urlpatterns as tool_config_urls
from dojo.tool_product.urls import urlpatterns as tool_product_urls
from dojo.cred.urls import urlpatterns as cred_urls
from dojo.system_settings.urls import urlpatterns as system_settings_urls
from dojo.notifications.urls import urlpatterns as notifications_urls
import sys
admin.autodiscover()
"""
Bind multiple resources together to form a coherent API.
"""
v1_api = Api(api_name='v1', )
v1_api.register(UserResource())
v1_api.register(ProductResource())
v1_api.register(EngagementResource())
v1_api.register(TestResource())
v1_api.register(FindingResource())
v1_api.register(FindingTemplateResource())
v1_api.register(ScanSettingsResource())
v1_api.register(ScanResource())
v1_api.register(StubFindingResource())
v1_api.register(ImportScanResource())
v1_api.register(ReImportScanResource())
# v1_api.register(IPScanResource())
ur = []
ur += dev_env_urls
ur += endpoint_urls
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: path('', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.urls import include, path
2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
"""
from django.contrib import admin
from django.urls import path
from django.conf.urls import include
from tastypie.api import Api
from app.resources import *
v1_api = Api(api_name='v1')
v1_api.register(UserByIdResource())
v1_api.register(PortfolioByIdResource())
v1_api.register(GoalByIdResource())
v1_api.register(AppointementsByUserIdResource())
v1_api.register(UserAuth())
v1_api.register(PortfolioInPdf())
v1_api.register(HelpResource())
urlpatterns = [
path('admin/', admin.site.urls),
path('api/', include(v1_api.urls))
]
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.conf.urls.defaults import patterns, include, url
from django.views.generic import TemplateView
from tastypie.api import Api
from lachambre.api import DeputyResource, CommissionMembershipRessource, CommissionResource, DocumentResource, WrittenQuestionResource, AnnualReportRessource
v1_api = Api(api_name='v1')
v1_api.register(AnnualReportRessource())
v1_api.register(DeputyResource())
v1_api.register(CommissionResource())
v1_api.register(CommissionMembershipRessource())
v1_api.register(DocumentResource())
v1_api.register(WrittenQuestionResource())
# Uncomment the next two lines to enable the admin:
# from django.contrib import admin
# admin.autodiscover()
urlpatterns = patterns(
'',
url(r'^$', TemplateView.as_view(template_name="home.html"), name='home'),
url(r'^lachambre/', include('lachambre.urls', namespace='deputies')),
url(r'^api/', include(v1_api.urls)),
from django.conf.urls import url, include
from django.core.urlresolvers import reverse
import registration.backends.default.urls
import django.contrib.auth.urls
from NMTK_server import api, views
from tastypie.api import Api
# Uncomment the next two lines to enable the admin:
from django.contrib import admin
import django.contrib.auth.views
admin.autodiscover()
v1_api = Api(api_name='v1')
v1_api.register(api.DataFileResource())
v1_api.register(api.UserResource())
v1_api.register(api.ToolResource())
# v1_api.register(api.ToolConfigResource())
v1_api.register(api.JobResource())
v1_api.register(api.JobFileResource())
v1_api.register(api.ResultsFileResource())
v1_api.register(api.JobStatusResource())
v1_api.register(api.FeedbackResource())
v1_api.register(api.UserPreference())
v1_api.register(api.ToolSampleFileResource())
v1_api.register(api.MapColorStyleResource())
v1_api.register(api.PageNameResource())
v1_api.register(api.PageContentResource())
urlpatterns = [
url('^ui/$', views.nmtk_ui, {}, name='nmtk_server_nmtk_ui'),
url('^$', views.nmtk_index, {}, name='nmtk_server_nmtk_index'),
url('^terms_of_service/$',
voice = fields.ForeignKey(VoiceResource, 'voice')
class Meta:
queryset = Dialogue.objects.all()
always_return_data = True
authorization = DjangoAuthorization()
filtering = {
'id': ALL,
'action': ALL_WITH_RELATIONS,
'voice': ALL_WITH_RELATIONS,
}
# API structure
v1_api = Api(api_name='v1')
v1_api.register(ActionResource())
v1_api.register(ActionTypeResource())
v1_api.register(DefaultActionSetResource())
v1_api.register(DialogueResource())
v1_api.register(GridResource())
v1_api.register(ItemComboResource())
v1_api.register(ItemResource())
v1_api.register(LayerResource())
v1_api.register(MatrixResource())
v1_api.register(SceneResource())
v1_api.register(TreeResource())
v1_api.register(TreeMenuResource())
v1_api.register(TreeTopicResource())
v1_api.register(VoiceResource())
url(r'^fake-login$', views.fake_login, name='sentry-fake-login'),
url(r'^trigger-500$', views.raise_exc, name='sentry-raise-exc'),
url(r'^trigger-500-ioerror$',
views.raise_ioerror,
name='sentry-raise-ioerror'),
url(r'^trigger-500-decorated$',
views.decorated_raise_exc,
name='sentry-raise-exc-decor'),
url(r'^trigger-500-django$', views.django_exc, name='sentry-django-exc'),
url(r'^trigger-500-template$',
views.template_exc,
name='sentry-template-exc'),
url(r'^trigger-500-log-request$',
views.logging_request_exc,
name='sentry-log-request-exc'),
url(r'^trigger-event$', views.capture_event, name='sentry-trigger-event'),
)
try:
from tastypie.api import Api
except ImportError:
pass
else:
from tests.contrib.django.api import ExampleResource, AnotherExampleResource
v1_api = Api(api_name='v1')
v1_api.register(ExampleResource())
v1_api.register(AnotherExampleResource())
urlpatterns += (url(r'^api/', include(v1_api.urls)), )
from django.conf import settings
from django.conf.urls.defaults import *
from django.views.generic.simple import direct_to_template
from django.contrib import admin
admin.autodiscover()
from pinax.apps.account.openid_consumer import PinaxConsumer
from tastypie.api import Api
from language.api import LanguageResource, UserResource
v1_api = Api(api_name='v1')
v1_api.register(UserResource())
v1_api.register(LanguageResource())
language_resource = LanguageResource()
handler500 = "pinax.views.server_error"
urlpatterns = patterns(
"",
url(r"^$",
direct_to_template, {
"template": "homepage.html",
},
name="home"),
url(r"^admin/invite_user/$",
"pinax.apps.signup_codes.views.admin_invite_user",
name="admin_invite_user"),
url(r"^admin/", include(admin.site.urls)),
url(r"^about/", include("about.urls")),
url(r"^account/", include("pinax.apps.account.urls")),
from django.conf.urls import patterns, url, include
from tastypie.api import Api
from yottaweb.apps.application.custom.resources import CustomResource
version_api = Api(api_name='v0')
version_api.register(CustomResource())
urlpatterns = patterns('yottaweb.apps.application.custom.views',
(r'^app/custom/([\w\d]+)/$', 'overview'),
(r'^app/table/([\w\d]+)/$', 'table'),
(r'^api/', include(version_api.urls))
)
# NG: facets for Haystack
sqs = (SearchQuerySet().using("core").models(DataSet).facet(
'measurement').facet('technology').highlight())
# Uncomment the next two lines to enable the admin:
admin.autodiscover()
# Django REST Framework urls
router = routers.DefaultRouter()
router.register(r'workflows', WorkflowViewSet)
# NG: added for tastypie URL
v1_api = Api(api_name='v1')
v1_api.register(AnalysisResource())
v1_api.register(ProjectResource())
v1_api.register(StudyResource())
v1_api.register(AssayResource())
v1_api.register(DataSetResource())
v1_api.register(AttributeOrderResource())
v1_api.register(NodeResource())
v1_api.register(NodeSetResource())
v1_api.register(NodeSetListResource())
v1_api.register(NodePairResource())
v1_api.register(NodeRelationshipResource())
v1_api.register(WorkflowResource())
v1_api.register(WorkflowInputRelationshipsResource())
v1_api.register(StatisticsResource())
v1_api.register(GroupManagementResource())
v1_api.register(UserAuthenticationResource())
from django.conf.urls import patterns, include, url
from tastypie.api import Api
from .api import RecipeResource, UserResource
v1_api = Api(api_name='v1')
v1_api.register(UserResource())
v1_api.register(RecipeResource())
urlpatterns = patterns(
'recipes.views',
url(r'^recipe/(?P<slug>[-\w]+)/$', 'detail', name='recipes_recipe_detail'),
url(r'^$', 'index', name='recipes_recipe_index'),
)
urlpatterns += patterns(
'',
url(r'^api/', include(v1_api.urls)),
)
def get_api_v2():
api = Api(api_name='v2')
api.register(TrackerResource())
api.register(CourseResource())
api.register(CategoryResource())
api.register(PointsResource())
api.register(AwardsResource())
api.register(BadgesResource())
api.register(UserResource())
api.register(RegisterResourceV2())
api.register(ResetPasswordResource())
api.register(ProfileUpdateResource())
api.register(QuizAttemptResource())
api.register(CourseStructureResource())
api.register(UserCourseSummaryResource())
api.register(UsernameResource())
api.register(DeleteAccountResource())
api.register(DownloadDataResource())
api.register(ChangePasswordResource())
return api
from django.contrib import admin
from django.conf import settings
from django.conf.urls.static import static
from django.views.generic.base import TemplateView
from tastypie.api import Api
from readthedocs.api.base import (ProjectResource, UserResource,
VersionResource, FileResource)
from readthedocs.core.urls import docs_urls, core_urls, deprecated_urls
from readthedocs.core.views import (HomepageView, SupportView,
server_error_404, server_error_500)
from readthedocs.search import views as search_views
v1_api = Api(api_name='v1')
v1_api.register(UserResource())
v1_api.register(ProjectResource())
v1_api.register(VersionResource())
v1_api.register(FileResource())
admin.autodiscover()
handler404 = server_error_404
handler500 = server_error_500
basic_urls = [
url(r'^$', HomepageView.as_view(), name='homepage'),
url(r'^support/', SupportView.as_view(), name='support'),
url(r'^security/', TemplateView.as_view(template_name='security.html')),
url(r'^.well-known/security.txt',
TemplateView.as_view(template_name='security.txt', content_type='text/plain')),
from django.conf.urls import patterns, include, url
from tastypie.api import Api
from todo.api import TasksResource, RootsResource, PropertiesResource, UsersResource, LogsResource
from django.contrib import admin
admin.autodiscover()
v1_api = Api(api_name='v1')
v1_api.register(TasksResource())
v1_api.register(RootsResource())
v1_api.register(PropertiesResource())
v1_api.register(UsersResource())
v1_api.register(LogsResource())
urlpatterns = patterns(
'',
# Examples:
# url(r'^$', 'adm.views.home', name='home'),
# url(r'^blog/', include('blog.urls')),
url(r'^admin/', include(admin.site.urls)),
(r'^api/', include(v1_api.urls)),
url(r'^$', 'todo.views.home', name='home'),
url(r'^logout/$', 'todo.views.logout_user', name='logout'),
)
"""
Tattletale is a Python web service for a realtime news feed
"""
from __future__ import absolute_import
__author__ = 'jag'
__copyright__ = 'Copyright (c) 2013, SocialCode'
__license__ = 'Confidential and proprietary - not licensed for distribution'
import logging
logger = logging.getLogger(__name__)
from tastypie.api import Api
from django.conf.urls.defaults import patterns, include
from .handlers import MessageResource
api = Api(api_name='v1')
api.register(MessageResource())
urlpatterns = patterns('', (r'', include(api.urls)))
from django.conf.urls.defaults import *
from tastypie.api import Api
from api import TestResource
api = Api('test')
api.register(TestResource())
urlpatterns = patterns('',
(r'^api/', include(api.urls)),
)
ComponentModelResource,
VariableModelResource)
from gcloud.commons.template.resources import (CommonTemplateResource,
CommonTemplateSchemeResource)
from gcloud.tasktmpl3.resources import (
TaskTemplateResource,
TemplateSchemeResource,
)
from gcloud.taskflow3.resources import TaskFlowInstanceResource
from gcloud.contrib.appmaker.resources import AppMakerResource
from gcloud.contrib.function.resources import FunctionTaskResource
from gcloud.periodictask.resources import PeriodicTaskResource
from gcloud.external_plugins.resources import PackageSourceResource, SyncTaskResource
v3_api = Api(api_name='v3')
v3_api.register(BusinessResource())
v3_api.register(TaskTemplateResource())
v3_api.register(ComponentModelResource())
v3_api.register(VariableModelResource())
v3_api.register(TemplateSchemeResource())
v3_api.register(TaskFlowInstanceResource())
v3_api.register(AppMakerResource())
v3_api.register(FunctionTaskResource())
v3_api.register(PeriodicTaskResource())
v3_api.register(CommonTemplateResource())
v3_api.register(CommonTemplateSchemeResource())
v3_api.register(PackageSourceResource())
v3_api.register(SyncTaskResource())
# Standard bits...
urlpatterns = [
