← Back to branch summary

~doflah/ubuntu-api-website/autosuggest

« back to all changes in this revision

Viewing changes to developer_network/web/views.py

  • Committer: Tarmac
  • Author(s): mhall119
  • Date: 2013-11-01 02:00:32 UTC
  • mfrom: (40.1.13 udn)
  • Revision ID: tarmac-20131101020032-qazfy5b3957etfa2
[r=Michael Hall] Adds the ability to edit content on various pages, adds SSO support and gives members of ~api-website-devs edit permissions. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
developer_network/web/views.py
2
2
from django.http import HttpResponse, HttpResponseRedirect
3
3
from django.core.urlresolvers import reverse
4
4
from django.template import loader, RequestContext
 
5
from django.forms import ModelForm
5
6
 
6
7
from common.models import Topic, Version, Section
7
8
from apidocs.models import Namespace, Element, Page
24
25
    }
25
26
    return render_to_response('web/distro.html', context, RequestContext(request))
26
27
 
 
28
class TopicForm(ModelForm):
 
29
    class Meta:
 
30
        model = Topic
 
31
 
 
32
def topic_edit(request, topic_id=0):
 
33
    if topic_id:
 
34
        topic = get_object_or_404(Topic, id=topic_id)
 
35
    else:
 
36
        topic = Topic()
 
37
 
 
38
    if not request.user.has_perm('common.change_topic'):
 
39
        return HttpResponseRedirect(reverse(topic_view, args=[topic.slug]))
 
40
 
 
41
    if request.method == 'POST':
 
42
        form = TopicForm(request.POST, instance=topic)
 
43
        if form.is_valid():
 
44
            form.save()
 
45
            return HttpResponseRedirect(reverse(topic_view, args=[topic.slug]))
 
46
    else:
 
47
        form = TopicForm(instance=topic)
 
48
    context = {
 
49
        'form': form,
 
50
        'topic': topic,
 
51
    }
 
52
    return render_to_response('web/topic_edit.html', context, RequestContext(request))
 
53
 
27
54
def version_view(request, topic_name, release_version):
28
55
    version = get_object_or_404(Version, topic__slug=topic_name, slug=release_version)
29
56
 
63
90
    }
64
91
    return render_to_response('web/release.html', context, RequestContext(request))
65
92
 
 
93
class VersionForm(ModelForm):
 
94
    class Meta:
 
95
        model = Version
 
96
 
 
97
def version_edit(request, topic_name, version_id=0):
 
98
    if version_id:
 
99
        version = get_object_or_404(Version, topic__slug=topic_name, id=version_id)
 
100
        topic = version.topic
 
101
    else:
 
102
        topic = get_object_or_404(Topic, slug=topic_name)
 
103
        version = Version(topic=topic)
 
104
 
 
105
    if not request.user.has_perm('common.change_version'):
 
106
        return HttpResponseRedirect(reverse(version_view, args=[topic.slug, version.slug]))
 
107
 
 
108
    if request.method == 'POST':
 
109
        form = VersionForm(request.POST, instance=version)
 
110
        if form.is_valid():
 
111
            form.save()
 
112
            return HttpResponseRedirect(reverse(version_view, args=[topic.slug, version.slug]))
 
113
    else:
 
114
        form = VersionForm(instance=version)
 
115
    context = {
 
116
        'form': form,
 
117
        'topic': topic,
 
118
        'version': version,
 
119
    }
 
120
    return render_to_response('web/version_edit.html', context, RequestContext(request))
 
121
 
 
122
class SectionForm(ModelForm):
 
123
    class Meta:
 
124
        model = Section
 
125
 
 
126
def section_edit(request, topic_name, version_name, section_id=0):
 
127
    if section_id:
 
128
        section = get_object_or_404(Section, topic_version__topic__slug=topic_name, topic_version__slug=version_name, id=section_id)
 
129
        version = section.topic_version
 
130
        topic = version.topic
 
131
    else:
 
132
        topic = get_object_or_404(Topic, slug=topic_name)
 
133
        version = get_object_or_404(Version, topic=topic, slug=version_name)
 
134
        section = Section(topic_version=version)
 
135
 
 
136
    if not request.user.has_perm('common.change_section'):
 
137
        return HttpResponseRedirect(reverse(version_view, args=[topic.slug, version.slug]))
 
138
 
 
139
    if request.method == 'POST':
 
140
        form = SectionForm(request.POST, instance=section)
 
141
        if form.is_valid():
 
142
            form.save()
 
143
            return HttpResponseRedirect(reverse(version_view, args=[topic.slug, version.slug]))
 
144
    else:
 
145
        form = SectionForm(instance=section)
 
146
    context = {
 
147
        'sidenav': topic_name,
 
148
        'form': form,
 
149
        'topic': topic,
 
150
        'version': version,
 
151
        'section': section,
 
152
    }
 
153
    return render_to_response('web/section_edit.html', context, RequestContext(request))
 
154
 
66
155
def namespace_view(request, topic_name, release_version, namespace_name):
67
156
    try:
68
157
        namespace = Namespace.objects.get(platform_section__topic_version__slug=release_version, platform_section__topic_version__topic__slug=topic_name, name=namespace_name)
82
171
    }
83
172
    return render_to_response('web/namespace.html', context, RequestContext(request))
84
173
 
 
174
class NamespaceForm(ModelForm):
 
175
    class Meta:
 
176
        model = Namespace
 
177
        
 
178
    def __init__(self, *args, **kargs):
 
179
        if 'version' in kargs:
 
180
            version = kargs['version']
 
181
            del kargs['version']
 
182
        elif hasattr(self, 'instance') and self.instance.section:
 
183
            version = self.instance.section.topic_version
 
184
        else:
 
185
            version=None
 
186
        super(NamespaceForm, self).__init__(*args, **kargs)
 
187
        self.fields['platform_section'].queryset = Section.objects.filter(topic_version=version)
 
188
                
 
189
def namespace_edit(request, topic_name, version_name, namespace_id=0):
 
190
    if namespace_id:
 
191
        namespace = get_object_or_404(Namespace, platform_section__topic_version__slug=version_name, platform_section__topic_version__topic__slug=topic_name, id=namespace_id)
 
192
        version = namespace.platform_section.topic_version
 
193
        topic = version.topic
 
194
    else:
 
195
        topic = get_object_or_404(Topic, slug=topic_name)
 
196
        version = get_object_or_404(Version, slug=version_name, topic=topic)
 
197
        namespace = Namespace()
 
198
 
 
199
    if not request.user.has_perm('apidocs.change_namespace'):
 
200
        return HttpResponseRedirect(reverse(element_view, args=[topic_name, version_name, namespace.name]))
 
201
 
 
202
    if request.method == 'POST':
 
203
        form = NamespaceForm(request.POST, instance=namespace, version=version)
 
204
        if form.is_valid():
 
205
            form.save()
 
206
            return HttpResponseRedirect(reverse(element_view, args=[topic_name, version_name, namespace.name]))
 
207
    else:
 
208
        form = NamespaceForm(instance=namespace, version=version)
 
209
    context = {
 
210
        'form': form,
 
211
        'sidenav': topic_name,
 
212
        'topic': topic,
 
213
        'version': version,
 
214
        'namespace': namespace,
 
215
    }
 
216
    return render_to_response('web/namespace_edit.html', context, RequestContext(request))
 
217
 
85
218
def page_view(request, topic_name, release_version, page_fullname):
86
219
    page = get_object_or_404(Page, section__topic_version__slug=release_version, section__topic_version__topic__slug=topic_name, fullname=page_fullname)
87
220
 
99
232
    }
100
233
    return render_to_response('web/page.html', context, RequestContext(request))
101
234
 
 
235
class PageForm(ModelForm):
 
236
    class Meta:
 
237
        model = Page
 
238
        
 
239
    def __init__(self, *args, **kargs):
 
240
        if 'version' in kargs:
 
241
            version = kargs['version']
 
242
            del kargs['version']
 
243
        elif hasattr(self, 'instance') and self.instance.section:
 
244
            version = self.instance.section.topic_version
 
245
        else:
 
246
            version=None
 
247
        super(PageForm, self).__init__(*args, **kargs)
 
248
        self.fields['section'].queryset = Section.objects.filter(topic_version=version)
 
249
        self.fields['namespace'].queryset = Namespace.objects.filter(platform_section__topic_version=version)
 
250
                
 
251
def page_edit(request, topic_name, release_version, page_id=0):
 
252
    if page_id:
 
253
        page = get_object_or_404(Page, section__topic_version__slug=release_version, section__topic_version__topic__slug=topic_name, id=page_id)
 
254
        version = page.section.topic_version
 
255
        topic = version.topic
 
256
    else:
 
257
        topic = get_object_or_404(Topic, slug=topic_name)
 
258
        version = get_object_or_404(Version, slug=release_version, topic=topic)
 
259
        page = Page()
 
260
 
 
261
    if not request.user.has_perm('apidocs.change_page'):
 
262
        return HttpResponseRedirect(reverse(version_view, args=[topic_name, release_version]))
 
263
 
 
264
    if request.method == 'POST':
 
265
        form = PageForm(request.POST, instance=page, version=version)
 
266
        if form.is_valid():
 
267
            form.save()
 
268
            return HttpResponseRedirect(reverse(version_view, args=[topic_name, release_version]))
 
269
    else:
 
270
        form = PageForm(instance=page, version=version)
 
271
    context = {
 
272
        'form': form,
 
273
        'sidenav': topic_name,
 
274
        'topic': topic,
 
275
        'version': version,
 
276
        'page': page,
 
277
    }
 
278
    return render_to_response('web/page_edit.html', context, RequestContext(request))
 
279
    
102
280
def element_view(request, topic_name, release_version, element_fullname):
103
281
    try:
104
282
        element = Element.objects.get(section__topic_version__slug=release_version, section__topic_version__topic__slug=topic_name, fullname=element_fullname)
120
298
        'tutorials': tutorials
121
299
    }
122
300
    return render_to_response('web/element.html', context, RequestContext(request))
 
301
 
 
302
class ElementForm(ModelForm):
 
303
    class Meta:
 
304
        model = Element
 
305
        
 
306
    def __init__(self, *args, **kargs):
 
307
        if 'version' in kargs:
 
308
            version = kargs['version']
 
309
            del kargs['version']
 
310
        elif hasattr(self, 'instance') and self.instance.section:
 
311
            version = self.instance.section.topic_version
 
312
        else:
 
313
            version=None
 
314
        super(ElementForm, self).__init__(*args, **kargs)
 
315
        self.fields['section'].queryset = Section.objects.filter(topic_version=version)
 
316
        self.fields['namespace'].queryset = Namespace.objects.filter(platform_section__topic_version=version)
 
317
                
 
318
def element_edit(request, topic_name, release_version, element_id=0):
 
319
    if element_id:
 
320
        element = get_object_or_404(Element, section__topic_version__slug=release_version, section__topic_version__topic__slug=topic_name, id=element_id)
 
321
        version = element.section.topic_version
 
322
        topic = version.topic
 
323
    else:
 
324
        topic = get_object_or_404(Topic, slug=topic_name)
 
325
        version = get_object_or_404(Version, slug=release_version, topic=topic)
 
326
        element = Element()
 
327
 
 
328
    if not request.user.has_perm('apidocs.change_element'):
 
329
        return HttpResponseRedirect(reverse(element_view, args=[topic_name, release_version, element.fullname]))
 
330
 
 
331
    if request.method == 'POST':
 
332
        form = ElementForm(request.POST, instance=element, version=version)
 
333
        if form.is_valid():
 
334
            form.save()
 
335
            return HttpResponseRedirect(reverse(element_view, args=[topic_name, release_version, element.fullname]))
 
336
    else:
 
337
        form = ElementForm(instance=element, version=version)
 
338
    context = {
 
339
        'form': form,
 
340
        'sidenav': topic_name,
 
341
        'topic': topic,
 
342
        'version': version,
 
343
        'element': element,
 
344
    }
 
345
    return render_to_response('web/element_edit.html', context, RequestContext(request))
123
346
    
124
347
def search(request, topic_name, release_version):
125
348
    version = get_object_or_404(Version, topic__slug=topic_name, slug=release_version)