from django.conf.urls import include, url
from tastypie.api import NamespacedApi
from namespaced.api.resources import NamespacedNoteResource, NamespacedUserResource
api = NamespacedApi(api_name='v1', urlconf_namespace='special')
api.register(NamespacedNoteResource(), canonical=True)
api.register(NamespacedUserResource(), canonical=True)
urlpatterns = [
url(r'^api/', include(api.urls, namespace='special')),
]
from django.conf.urls import patterns, url, include
from django.views.decorators.csrf import csrf_exempt
from speeches.views import *
from speeches.search import InstanceSearchView
from speeches.views import Select2AutoResponseView
try:
from tastypie.api import NamespacedApi
from speeches.api import SpeechResource, SpeakerResource, SectionResource
# XXX The below assumes this app is being included with a 'speeches' namespace.
# Unclear how to have this inherit whichever namespace is being used.
v01_api = NamespacedApi(api_name='v0.1', urlconf_namespace='speeches')
v01_api.register(SpeakerResource())
v01_api.register(SpeechResource())
v01_api.register(SectionResource())
except:
v01_api = None
urlpatterns = patterns(
'',
url(r'^$', InstanceView.as_view(), name='home'),
# Override the usual AutoResponseView from django_select2 so as to limit
# results by instance
url(r"^select2/fields/auto.json$",
Select2AutoResponseView.as_view(),
name="django_select2_central_json"),
url(r'^(?P<path>speaker|recording)/?$', AddAnSRedirectView.as_view()),
url(r'^(?P<path>speech)/?$', AddAnSRedirectView.as_view(suffix='es')),
url(r'^search/',
from django.conf.urls import patterns, url, include
from tastypie.api import NamespacedApi
from apps.graph.api import ConceptResource, GraphResource, ConceptResourceResource, DependencyResource, GoalResource,\
TargetGraphResource, FullTargetGraphResource, GlobalResourceResource, ResourceLocationResource
from views import *
# api v1
v1_api = NamespacedApi(api_name='v1', urlconf_namespace='graphs')
v1_api.register(ConceptResource())
v1_api.register(ConceptResourceResource())
v1_api.register(GlobalResourceResource())
v1_api.register(ResourceLocationResource())
v1_api.register(GraphResource())
v1_api.register(TargetGraphResource())
v1_api.register(FullTargetGraphResource())
v1_api.register(DependencyResource())
v1_api.register(GoalResource())
#import pdb; pdb.set_trace()
# TODO refactor concepts
urlpatterns = patterns(
'',
url(r'^$', "django.views.defaults.page_not_found"),
url(r'^concept-triplet/?$', get_concept_triplet, name='concept_triplet'),
url(r'^autocomplete/?$', get_autocomplete, name='autocomplete'),
url(r'^(?i)concepts/([^/]+)/history/?$',
get_concept_history,
name="concept-history"),
v1_api.register(FolderResource())
# /user
# /user/archives
# /user/folders
# /user/organizations
# /user/capture_jobs
v1_api.register(CurrentUserResource())
v1_api.register(CurrentUserLinkResource())
v1_api.register(CurrentUserFolderResource())
v1_api.register(CurrentUserOrganizationResource())
v1_api.register(CurrentUserCaptureJobResource())
### v1a ###
v1a_api = NamespacedApi(api_name='v1a', urlconf_namespace='v1a')
v1a_api._registry = v1_api._registry.copy()
v1a_api._canonicals = v1_api._canonicals.copy()
### v2 ###
v2_api_urls = [
url(r'^v2/', include('api2.urls')),
]
### add API versions to urlpatters ###
urlpatterns = v1_api.urls + v1a_api.urls + v2_api_urls + collateral_urls
### error handlers ###
from django.conf.urls import url, include
from django.views.decorators.cache import cache_page
from tastypie.api import NamespacedApi
from status.api import IncidentResource, StatusResource
from status.models import Incident
from status.views import (DashboardView, HomeView, IncidentArchiveMonthView,
IncidentArchiveYearView, IncidentDeleteView,
IncidentDetailView, IncidentUpdateUpdateView,
create_incident, IncidentHideView,
HiddenDashboardView)
v1_api = NamespacedApi(api_name='v1', urlconf_namespace='status')
v1_api.register(StatusResource())
v1_api.register(IncidentResource())
urlpatterns = [
url(r'^api/', include(v1_api.urls)),
url(r'^$', cache_page(15)(HomeView.as_view()), name='home'),
url(r'^dashboard/$', DashboardView.as_view(), name='dashboard'),
url(r'^dashboard/hidden/$',
HiddenDashboardView.as_view(),
name='dashboard_hidden'),
url(r'^incident/new/$', create_incident, name='incident_create'),
url(r'^incident/(?P<pk>\d+)/$',
IncidentDetailView.as_view(model=Incident),
name='incident_detail'),
url(r'^incident/(?P<pk>\d+)/update/$',
IncidentUpdateUpdateView.as_view(),
name='incident_update'),
url(r'^incident/(?P<pk>\d+)/hide/$',
IncidentHideView.as_view(),
from .resources import *
from django.conf.urls import patterns, include, url
from tastypie.api import NamespacedApi
api = NamespacedApi(api_name='v1', urlconf_namespace='energy')
api.register(SummaryResource())
api.register(AmountResource())
api.register(CommentaryResource())
api.register(CountryResource())
api.register(DistributionResource())
api.register(FundraisingRoundResource())
api.register(OrganizationResource())
api.register(PersonResource())
api.register(PriceResource())
api.register(RevenueResource())
api.register(EnergyProductResource())
api.register(EnergyProjectResource())
urlpatterns = patterns(
'energy',
url(r'', include(api.urls)),
)
from tastypie.api import NamespacedApi from resources import DocumentationResource from resources import CategoryResource v1_api = NamespacedApi(api_name='v1') v1_api.register(DocumentationResource()) v1_api.register(CategoryResource())
from django.urls import path, include
from django.conf import settings
from django.conf.urls.static import static
from django.contrib.auth import views as auth_views
from tastypie.api import NamespacedApi
from .resources import ServiceResource, ImageResource, CompanyResource, CommentResource, ApiKeyResource, UserResource
from . import views
app_name = 'viciapp'
v1_api = NamespacedApi(api_name='v1', urlconf_namespace=app_name)
v1_api.register(ServiceResource())
v1_api.register(UserResource())
v1_api.register(ImageResource())
v1_api.register(CompanyResource())
v1_api.register(CommentResource())
v1_api.register(ApiKeyResource())
urlpatterns = [
# Main pages
path('', views.index, name='index'),
path('about/', views.about, name='about'),
path('login/', views.login_view, name='login'),
path('logout/', views.logout, name='logout'),
path('edit_profile/', views.edit_profile, name='edit_profile'),
path('terms_and_conditions/', views.tac, name='terms_and_conditions'),
# Processing pages
path('login_process/', views.login_process, name='login_process'),
# path('edit_profile_process/', views.edit_profile_process, name='edit_profile_process'),
return not bundle.request.user.is_anonymous()
class MyChannelResource(NamespacedModelResource):
source = fields.CharField(blank=True)
class Meta:
Channel = apps.get_model('tv', 'Channel')
queryset = Channel.objects.filter(enabled=True, source__isnull=False)
# excludes = ['enabled', 'description', 'enabled', 'name']
fields = ['id', 'channelid', 'number', 'buffer_size']
allowed_methods = ['get']
resource_name = 'userchannel'
authorization = MyChannelResourceAuthorization()
authentication = MultiAuthentication(
BasicAuthentication(realm='cianet-middleware'),
SessionAuthentication(), Authentication(), ApiKeyAuthentication())
def dehydrate_source(self, bundle):
return '%s:%d' % (bundle.obj.source.ip, bundle.obj.source.port)
api_v1 = NamespacedApi(api_name='v1', urlconf_namespace='tv_v1')
api_v1.register(ChannelResource())
api_v2 = NamespacedApi(api_name='v2', urlconf_namespace='tv_v2')
api_v2.register(AllChannelResource())
api_v2.register(MyChannelResource())
apis = [api_v1, api_v2]
),
url(r'^about/$', BaseView.as_view(
metadata='metadata/about.html'),
name='about'
),
url(r'^hut/new/$', BaseView.as_view(
metadata='metadata/hut_new.html'),
name='hut_new'
),
url(r'^partials/(?P<template>\w+)\.html$', DynamicTemplateView.as_view(folder='partials')),
)
# api
v1_api = NamespacedApi(api_name='v1', urlconf_namespace='huts_api')
v1_api.register(RegionResource())
v1_api.register(DesignationResource())
v1_api.register(SystemResource())
v1_api.register(AccessTypeResource())
v1_api.register(HutTypeResource())
v1_api.register(ServiceResource())
v1_api.register(AgencyResource())
v1_api.register(HutResource())
v1_api.register(HutSuggestionResource())
api_patterns = patterns('',
url(r'', include(v1_api.urls)),
)
"message": ALL,
"url": ALL,
}
authorization = ProgramScheduleAuthorization()
validation = ProgramScheduleValidation()
serializer = SetTopBoxSerializer(formats=['json'])
authentication = MultiAuthentication(
ApiKeyAuthentication(),
BasicAuthentication(realm='cianet-middleware'),
Authentication(),)
class SetTopBoxBehaviorFlagResource(NamespacedModelResource):
class Meta:
SetTopBoxBehaviorFlag = apps.get_model('client', 'SetTopBoxBehaviorFlag')
queryset = SetTopBoxBehaviorFlag.objects.all()
api = NamespacedApi(api_name='v1', urlconf_namespace='client_v1')
api.register(SetTopBoxResource())
api.register(SetTopBoxParameterResource())
api.register(SetTopBoxChannelResource())
api.register(SetTopBoxConfigResource())
api.register(APIKeyResource())
api.register(SetTopBoxMessage())
api.register(SetTopBoxProgramScheduleResource())
api.register(SetTopBoxBehaviorFlagResource())
apis = [api]
def topic_models(path, force=False):
"""
Auto-discover topic-related model by looking into
a topic package for an ontology file. This will also
create all api resources and endpoints.
This will create the following modules:
{path}
{path}.models
{path}.resources
{path}.summary
{path}.urls
"""
# Clean the topic virtual instances from sys.module
if force: clean_topic(path)
topic_module = import_or_create(path, force=force)
topic_name = path.split(".")[-1]
# Ensure that the topic's model exist
topic = Topic.objects.get(ontology_as_mod=topic_name)
app_label = topic.app_label()
reload_models(app_label)
# Add '.models to the path if needed
models_path = path if path.endswith(".models") else '%s.models' % path
urls_path = "%s.urls" % path
# Import or create virtually the models.py file
models_module = import_or_create(models_path, force=force)
try:
# Generates all model using the ontology file.
# Also overides the default app label to allow data persistance
if topic.ontology_as_json is not None:
# JSON ontology
models = parser.json.parse(topic.ontology_as_json,
path,
app_label=app_label)
elif topic.ontology_as_owl is not None:
# OWL ontology
models = parser.owl.parse(topic.ontology_as_owl,
path,
app_label=app_label)
else:
models = []
# except TypeError as e:
# if settings.DEBUG: print 'TypeError:', e
# models = []
except ValueError as e:
if settings.DEBUG: print 'ValueError:', e
models = []
# Makes every model available through this module
for m in models:
# Record the model
setattr(models_module, m, models[m])
# Generates the API endpoints
api = NamespacedApi(api_name='v1', urlconf_namespace=app_label)
# Create resources root if needed
resources = import_or_create("%s.resources" % path, force=force)
# Creates a resource for each model
for name in models:
Resource = utils.create_model_resource(models[name])
resource_name = "%sResource" % name
# Register the virtual resource to by importa
resource_path = "%s.resources.%s" % (path, resource_name)
# This resource is now available everywhere:
# * as an attribute of `resources`
# * as a module
setattr(resources, resource_name, Resource)
# And register it into the API instance
api.register(Resource())
# Every app have to instance a SummaryResource class
summary_path = "%s.summary" % path
summary_module = import_or_create(summary_path, force=force)
# Take the existing summary resource
if hasattr(summary_module, 'SummaryResource'):
SummaryResource = summary_module.SummaryResource
# We create one if it doesn't exist
else:
from app.detective.topics.common.summary import SummaryResource as CommonSummaryResource
attrs = dict(meta=CommonSummaryResource.Meta)
SummaryResource = type('SummaryResource', (CommonSummaryResource, ),
attrs)
# Register the summary resource
api.register(SummaryResource())
# Create url patterns
urlpatterns = patterns(
path,
url('', include(api.urls)),
)
# Import or create virtually the url path
urls_modules = import_or_create(urls_path, force=force)
# Merge the two url patterns if needed
if hasattr(urls_modules, "urlpatterns"):
urlpatterns += urls_modules.urlpatterns
# Update the current url pattern
urls_modules.urlpatterns = urlpatterns
# API is now up and running,
# we need to connect its url patterns to global one
urls = importlib.import_module("app.detective.urls")
# Add api url pattern with the highest priority
new_patterns = patterns(
app_label,
url(r'^{0}/{1}/'.format(topic.author, topic.slug),
include(urls_path, namespace=app_label)),
)
if hasattr(urls, "urlpatterns"):
# Merge with a filtered version of the urlpattern to avoid duplicates
new_patterns += [
u for u in urls.urlpatterns
if getattr(u, "namespace", None) != app_label
]
# Then update url pattern
urls.urlpatterns = new_patterns
# At last, force the url resolver to reload (because we update it)
clear_url_caches()
reload_urlconf()
topic_module.__name__ = path
sys.modules[path] = topic_module
return topic_module
