root/src/domogik/ui/djangodomo/core/views.py @ 1506:73fd160d0a83

Revision 1506:73fd160d0a83, 19.5 kB (checked in by Ferllings <cedric@…>, 6 months ago)

[django] REST Auth login
Line 
1#!/usr/bin/python
2# -*- coding: utf-8 -*-
3
4""" This file is part of B{Domogik} project (U{http://www.domogik.org}).
5
6License
7=======
8
9B{Domogik} is free software: you can redistribute it and/or modify
10it under the terms of the GNU General Public License as published by
11the Free Software Foundation, either version 3 of the License, or
12(at your option) any later version.
13
14B{Domogik} is distributed in the hope that it will be useful,
15but WITHOUT ANY WARRANTY; without even the implied warranty of
16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17GNU General Public License for more details.
18
19You should have received a copy of the GNU General Public License
20along with Domogik. If not, see U{http://www.gnu.org/licenses}.
21
22Module purpose
23==============
24
25Django web UI views
26
27Implements
28==========
29
30
31@author: Domogik project
32@copyright: (C) 2007-2009 Domogik project
33@license: GPL(v3)
34@organization: Domogik
35"""
36
37import datetime
38import math
39import os
40import simplejson
41from subprocess import *
42
43from django.core import serializers
44from django.db.models import Q
45from django.http import QueryDict
46from django.http import Http404, HttpResponse
47from django.shortcuts import render_to_response
48from django.template import RequestContext
49from django.utils.translation import ugettext_lazy as _
50
51from domogik.common import database
52from djangodomo.core.models import *
53
54from djangodomo.core.sample_data_helper import SampleDataHelper
55from djangodomo.core.XPLHelper import XPLHelper
56
57from django.views.decorators.cache import never_cache
58from django_pipes.exceptions import ResourceNotAvailableException
59
60__ADMIN_MANAGEMENT_DOMOGIK = 'admin/management/domogik.html'
61__db = database.DbHelper()
62
63def index(request):
64    """
65    Method called when the main page is accessed
66    @param request : the HTTP request
67    @return an HttpResponse object
68    """
69    page_title = _("Domogik Homepage")
70
71    try:
72        resultAllRooms = Rooms.getAll()
73        resultAllRooms.merge_uiconfig()
74        resultHouse = UIConfigs.getGeneral('house')
75    except ResourceNotAvailableException:
76        return render_to_response('error/ResourceNotAvailableException.html')
77
78    device_list = []
79    for device in __db.list_devices():
80      device_list.append({'room': device.room_id, 'device': device})
81
82    return __go_to_page(request, 'index.html',
83        page_title,
84        rooms_list=resultAllRooms.room,
85        device_list=device_list,
86        house=resultHouse
87    )
88
89def login(request):
90    """
91    Login process
92    @param request : HTTP request
93    @return an HttpResponse object
94    """
95    page_title = _("Login page")
96    status = ''
97    msg = ''
98    if request.method == 'POST':
99        # An action was submitted => login action
100        login = QueryDict.get(request.POST, "login", False)
101        password = QueryDict.get(request.POST, "password", False)
102        try:
103            resultAuth = Accounts.Auth(login, password)
104        except ResourceNotAvailableException:
105            return render_to_response('error/ResourceNotAvailableException.html')
106           
107        if resultAuth.status == 'OK':
108            account = resultAuth.account[0]
109            request.session['user'] = {
110                'login': account.login,
111                'is_admin': (account.is_admin == "True"),
112                'first_name': account.person.first_name,
113                'last_name': account.person.last_name,
114                'skin_used': account.skin_used
115            }
116            return index(request)
117        else:
118            # User not found, ask again to log in
119            error_msg = _("Sorry unable to log in. Please check login name / password and try again.")
120            try:
121                resultAllAccounts = Accounts.getAllUsers()
122            except ResourceNotAvailableException:
123                return render_to_response('error/ResourceNotAvailableException.html')
124            return __go_to_page(
125                request, 'login.html',
126                page_title,
127                error_msg=error_msg,
128                account_list=resultAllAccounts.account
129            )
130    else:
131        # User asked to log in
132        try:
133            resultAllAccounts = Accounts.getAllUsers()
134        except ResourceNotAvailableException:
135            return render_to_response('error/ResourceNotAvailableException.html')
136        return __go_to_page(
137            request, 'login.html',
138            page_title,
139            account_list=resultAllAccounts.account
140        )
141
142def logout(request):
143    """
144    Logout process
145    @param request: HTTP request
146    @return an HttpResponse object
147    """
148    request.session.clear()
149    return index(request)
150
151def admin_index(request):
152    """
153    Method called when the admin page is accessed
154    @param request : HTTP request
155    @return an HttpResponse object
156    """
157    if not __is_user_admin(request):
158        return index(request)
159    page_title = _("Admin page")
160    return __go_to_page(request, 'admin/index.html', page_title)
161
162def admin_management_domogik(request):
163    """
164    Method called when the admin domogik management page is accessed
165    @param request : HTTP request
166    @return an HttpResponse object
167    """
168    if not __is_user_admin(request):
169        return index(request)
170    simulation_mode = ""
171    admin_mode = ""
172    debug_mode = ""
173    page_title = _("Gestion de Domogik")
174    action = "index"
175    sys_config = __db.get_system_config()
176    if sys_config.simulation_mode:
177        simulation_mode = "checked"
178    if __is_user_admin(request):
179        admin_mode = "checked"
180    if sys_config.debug_mode:
181        debug_mode = "checked"
182    return __go_to_page(request, __ADMIN_MANAGEMENT_DOMOGIK, page_title,
183                       action=action, simulation_mode=simulation_mode,
184                       admin_mode=admin_mode, debug_mode=debug_mode)
185
186def save_admin_settings(request):
187    """
188    Save the administrator settings (admin, debug and simulation mode
189    @param request : HTTP request
190    @return an HttpResponse object
191    """
192    if not __is_user_admin(request):
193        return index(request)
194
195    if request.method == 'POST':
196        simulation_mode = QueryDict.get(request.POST, "simulation_mode", False)
197        admin_mode = QueryDict.get(request.POST, "admin_mode", False)
198        debug_mode = QueryDict.get(request.POST, "debug_mode", False)
199        __db.update_system_config(s_simulation_mode=simulation_mode,
200                                 s_debug_mode=debug_mode)
201    return admin_management_domogik(request)
202
203def load_sample_data(request):
204    """
205    Load sample data
206    @param request : HTTP request
207    @return an HttpResponse object
208    """
209    if not __is_user_admin(request):
210        return index(request)
211
212    page_title = _(u"Chargement d'un jeu de données de test")
213    action = "loadSampleData"
214
215    sys_config = __db.get_system_config()
216    if sys_config.simulation_mode != True:
217        error_msg = _("The application is not running in simulation mode : can't load sample data")
218        return __go_to_page(request, __ADMIN_MANAGEMENT_DOMOGIK,
219                           page_title, action=action, error_msg=error_msg)
220
221    sample_data_helper = SampleDataHelper(__db)
222    sample_data_helper.create()
223
224    area_list = __db.list_areas()
225    room_list = __db.list_rooms()
226    device_usage_list = __db.list_device_usages()
227    device_list = __db.list_devices()
228    device_tech_list = __db.list_device_technologies()
229    return __go_to_page(request, __ADMIN_MANAGEMENT_DOMOGIK, page_title,
230                       action=action, area_list=area_list, room_list=room_list,
231                       device_usage_list=device_usage_list,
232                       device_list=device_list, device_tech_list=device_tech_list)
233
234def clear_data(request):
235    """
236    Clear all data of the system (in the database). Please use with care!
237    @param request : HTTP request
238    @return an HttpResponse object
239    """
240    if not __is_user_admin(request):
241        return index(request)
242
243    page_title = _("Remove all data")
244    action = "clearData"
245
246    sys_config = __db.get_system_config()
247    if sys_config.simulation_mode != True:
248        error_msg = _("The application is not running in simulation mode : can't clear data")
249        return __go_to_page(request, __ADMIN_MANAGEMENT_DOMOGIK, page_title,
250                           action=action, error_msg=error_msg)
251
252    sample_data_helper = SampleDataHelper(__db)
253    sample_data_helper.remove()
254    return __go_to_page(request, __ADMIN_MANAGEMENT_DOMOGIK, page_title,
255                       action=action)
256
257def __go_to_page(request, html_page, page_title, **attribute_list):
258    """
259    Common method called to go to an html page
260    @param request : HTTP request
261    @param html_page : the page to go to
262    @param page_title : page title
263    @param **attribute_list : list of attributes (dictionnary) that need to be
264           put in the HTTP response
265    @return an HttpResponse object
266    """
267    response_attr_list = {}
268    response_attr_list['page_title'] = page_title
269    response_attr_list['sys_config'] = __db.get_system_config()
270    response_attr_list['is_user_connected'] = __is_user_connected(request)
271    for attribute in attribute_list:
272        response_attr_list[attribute] = attribute_list[attribute]
273    return render_to_response(html_page, response_attr_list,
274                              context_instance=RequestContext(request))
275
276def __get_user_connected(request):
277    """
278    Get current user connected
279    @param request : HTTP request
280    @return the user or None
281    """
282    try:
283        return request.session['user']
284    except KeyError:
285        return None
286
287def __is_user_connected(request):
288    """
289    Check if the user is connected
290    @param request : HTTP request
291    @return True or False
292    """
293    try:
294        request.session['user']
295        return True
296    except KeyError:
297        return False
298
299def __is_user_admin(request):
300    """
301    Check if user has administrator rights
302    @param request : HTTP request
303    @return True or False
304    """
305    user = __get_user_connected(request)
306    return user is not None and user['is_admin']
307
308def admin_management_accounts(request):
309    """
310    Method called when the admin accounts page is accessed
311    @param request : HTTP request
312    @return an HttpResponse object
313    """
314    if not __is_user_admin(request):
315        return index(request)
316
317    status = request.GET.get('status', '')
318    msg = request.GET.get('msg', '')
319    try:
320        resultAllAccounts = Accounts.getAllUsers()
321    except ResourceNotAvailableException:
322        return render_to_response('error/ResourceNotAvailableException.html')
323    page_title = _("Accounts management")
324    return __go_to_page(
325        request, 'admin/management/accounts.html',
326        page_title,
327        nav1_admin = "selected",
328        nav2_management_accounts = "selected",
329        status=status,
330        msg=msg,
331        accounts_list=resultAllAccounts.account
332    )
333   
334def admin_organization_devices(request):
335    """
336    Method called when the admin devices organization page is accessed
337    @param request : HTTP request
338    @return an HttpResponse object
339    """
340    if not __is_user_admin(request):
341        return index(request)
342
343    status = request.GET.get('status', '')
344    msg = request.GET.get('msg', '')
345   
346    try:
347        resultAllDevices = Devices.getAll()
348        resultAllDevices.merge_uiconfig()
349        resultUnattribuedDevices = Devices.getWithoutRoom()
350        resultAllRooms = Rooms.getAllWithDevices()
351        resultAllRooms.merge_uiconfig()
352        resultAllUsages = DeviceUsages.getAll()
353        resultAllTypes = DeviceTypes.getAll()
354
355    except ResourceNotAvailableException:
356        return render_to_response('error/ResourceNotAvailableException.html')
357   
358    page_title = _("Devices organization")
359    return __go_to_page(
360        request, 'admin/organization/devices.html',
361        page_title,
362        nav1_admin = "selected",
363        nav2_organization_devices = "selected",
364        status=status,
365        msg=msg,
366        unattribued_devices=resultUnattribuedDevices.device,
367        rooms_list=resultAllRooms.room,
368        devices_list=resultAllDevices.device,
369        usages_list=resultAllUsages.device_usage,
370        types_list=resultAllTypes.device_type
371    )
372
373def admin_organization_rooms(request):
374    """
375    Method called when the admin rooms organization page is accessed
376    @param request : HTTP request
377    @return an HttpResponse object
378    """
379    if not __is_user_admin(request):
380        return index(request)
381
382    status = request.GET.get('status', '')
383    msg = request.GET.get('msg', '')
384    try:
385        resultAllRooms = Rooms.getAll()
386        resultAllRooms.merge_uiconfig()
387        resultUnattribuedRooms = Rooms.getWithoutArea()
388        resultAllAreas = Areas.getAllWithRooms()
389        resultAllAreas.merge_uiconfig()
390    except ResourceNotAvailableException:
391        return render_to_response('error/ResourceNotAvailableException.html')
392       
393    page_title = _("Rooms organization")
394    return __go_to_page(
395        request, 'admin/organization/rooms.html',
396        page_title,
397        nav1_admin = "selected",
398        nav2_organization_rooms = "selected",
399        status=status,
400        msg=msg,
401        unattribued_rooms=resultUnattribuedRooms.room,
402        rooms_list=resultAllRooms.room,
403        areas_list=resultAllAreas.area
404    )
405
406def admin_organization_areas(request):
407    """
408    Method called when the admin areas organization page is accessed
409    @param request : HTTP request
410    @return an HttpResponse object
411    """
412    if not __is_user_admin(request):
413        return index(request)
414
415    status = request.GET.get('status', '')
416    msg = request.GET.get('msg', '')
417    try:
418        resultAllAreas = Areas.getAll()
419        resultAllAreas.merge_uiconfig()
420    except ResourceNotAvailableException:
421        return render_to_response('error/ResourceNotAvailableException.html')
422    page_title = _("Areas organization")
423    return __go_to_page(
424        request, 'admin/organization/areas.html',
425        page_title,
426        nav1_admin = "selected",
427        nav2_organization_areas = "selected",
428        status=status,
429        msg=msg,
430        areas_list=resultAllAreas.area
431    )
432
433def admin_organization_house(request):
434    """
435    Method called when the admin house organization page is accessed
436    @param request : HTTP request
437    @return an HttpResponse object
438    """
439    if not __is_user_admin(request):
440        return index(request)
441
442    status = request.GET.get('status', '')
443    msg = request.GET.get('msg', '')
444    try:
445        resultHouse = UIConfigs.getGeneral('house')
446    except ResourceNotAvailableException:
447        return render_to_response('error/ResourceNotAvailableException.html')
448    page_title = _("House organization")
449    return __go_to_page(
450        request, 'admin/organization/house.html',
451        page_title,
452        nav1_admin = "selected",
453        nav2_organization_house = "selected",
454        status=status,
455        msg=msg,
456        house=resultHouse
457    )
458   
459def admin_modules_module(request, module_name):
460    """
461    Method called when the admin module command page is accessed
462    @param request : HTTP request
463    @return an HttpResponse object
464    """
465    if not __is_user_admin(request):
466        return index(request)
467
468    status = request.GET.get('status', '')
469    msg = request.GET.get('msg', '')
470    try:
471        resultModuleByName = Modules.getByName(module_name)
472        resultAllModules = Modules.getAll()
473    except ResourceNotAvailableException:
474        return render_to_response('error/ResourceNotAvailableException.html')
475    page_title = _("Module")
476    return __go_to_page(
477        request, 'admin/modules/module.html',
478        page_title,
479        nav1_admin = "selected",
480        nav2_modules_module = "selected",
481        modules_list=resultAllModules.module,
482        status=status,
483        msg=msg,
484        module=resultModuleByName.module[0]
485    )
486   
487def show_house(request):
488    """
489    Method called when the show index page is accessed
490    @param request : HTTP request
491    @return an HttpResponse object
492    """
493    page_title = _("View House")
494    try:
495        resultAllAreas = Areas.getAll()
496        resultAllAreas.merge_uiconfig()
497        resultHouse = UIConfigs.getGeneral('house')
498    except ResourceNotAvailableException:
499        return render_to_response('error/ResourceNotAvailableException.html')   
500    return __go_to_page(
501        request, 'show/house.html',
502        page_title,
503        nav1_show = "selected",
504        areas_list=resultAllAreas.area,
505        house=resultHouse
506    )
507
508
509def show_area(request, area_id):
510    """
511    Method called when the show area page is accessed
512    @param request : HTTP request
513    @return an HttpResponse object
514    """
515    try:
516        resultAreaById = Areas.getById(area_id)
517        resultAreaById.merge_uiconfig()
518        resultRoomsByArea = Rooms.getByArea(area_id)
519        resultRoomsByArea.merge_uiconfig()
520        resultHouse = UIConfigs.getGeneral('house')       
521    except ResourceNotAvailableException:
522        return render_to_response('error/ResourceNotAvailableException.html')
523       
524    page_title = _("View ") + resultAreaById.area[0].name
525    return __go_to_page(
526        request, 'show/area.html',
527        page_title,
528        nav1_show = "selected",
529        area=resultAreaById.area[0],
530        rooms_list=resultRoomsByArea.room,
531        house=resultHouse
532    )
533
534def show_room(request, room_id):
535    """
536    Method called when the show room page is accessed
537    @param request : HTTP request
538    @return an HttpResponse object
539    """
540    try:
541        resultRoomById = Rooms.getById(room_id)
542        resultRoomById.merge_uiconfig()
543        resultDevicesByRoom = Devices.getByRoom(room_id)
544        resultHouse = UIConfigs.getGeneral('house')
545    except ResourceNotAvailableException:
546        return render_to_response('error/ResourceNotAvailableException.html')
547   
548    page_title = _("View ") + resultRoomById.room[0].name
549    return __go_to_page(
550        request, 'show/room.html',
551        page_title,
552        nav1_show = "selected",
553        room=resultRoomById.room[0],
554        devices_list=resultDevicesByRoom.device,
555        house=resultHouse
556    )
557
558def show_device(request, device_id):
559    """
560    Method called when the show device page is accessed
561    @param request : HTTP request
562    @return an HttpResponse object
563    """
564    try:
565        resultHouse = UIConfigs.getGeneral('house')
566    except ResourceNotAvailableException:
567        return render_to_response('error/ResourceNotAvailableException.html')
568
569    device = __db.get_device(device_id)
570    room_id = device.room_id
571    room = __db.get_room_by_id(room_id)
572    room_name = room.name
573    area_id = room.area_id
574    area_name = (__db.get_area_by_id(area_id)).name
575    page_title = _("View")
576    return __go_to_page(
577        request, 'show/device.html',
578        page_title,
579        nav1_show = "selected",
580        device=device,
581        area_id=area_id,
582        area_name=area_name,
583        room_id=room_id,
584        room_name=room_name,
585        house=resultHouse
586    )
587
588def admin_visualization_devices(request):
589    """
590    Method called when the admin devices visualization page is accessed
591    @param request : HTTP request
592    @return an HttpResponse object
593    """
594    if not __is_user_admin(request):
595        return index(request)
596
597    status = request.GET.get('status', '')
598    msg = request.GET.get('msg', '')
599    try:
600        resultAllRooms = Rooms.getAllWithDevices()
601        resultAllRooms.merge_uiconfig()
602    except ResourceNotAvailableException:
603        return render_to_response('error/ResourceNotAvailableException.html')
604       
605    page_title = _("Devices visualization")
606    return __go_to_page(
607        request, 'admin/visualization/devices.html',
608        page_title,
609        nav1_admin = "selected",
610        nav2_visualization_devices = "selected",
611        status=status,
612        msg=msg,
613        rooms_list=resultAllRooms.room,
614    )
Note: See TracBrowser for help on using the browser.