source: trunk/oforgetools/projects/views.py @ 854

#
# Copyright 2008 Optaros, Inc
#
import random
import re
import sys
import logging
import traceback

from logging import handlers

import cjson

from django.core.paginator import Paginator
from django.core.urlresolvers import reverse
from django.http import HttpResponse, HttpResponseRedirect
from django.template import Context, RequestContext, loader
from django.shortcuts import render_to_response

from oforgetools.projects.models import Project, ProjectManager, Ticket, CustomProjectAttributes
from oforgetools.projects.models import OForgeProfile, OForgeProfileManager
from oforgetools.projects.forms import CreateProjectForm
from oforgetools import settings
from tagging.models import Tag, TaggedItem

from oforge.api import OForge

oforge_logger_initialized = False

def index(request):
    data = {}
    data['my_project_count'] = _get_user_projects_count(request.user)
    data['my_tickets_count'] = _get_user_tickets_count(request.user.username)
    data['featured_projects'] = _get_featured_projects()

    return render_to_response('projects/index.html', 
                              {'data': data},
                              context_instance=RequestContext(request))

def search(request):
    data = {'types': ProjectManager.reference_data('type'),
            'phases': CustomProjectAttributes.reference_values('phase'),
            'regions': CustomProjectAttributes.reference_values('region') }
    data['my_project_count'] = _get_user_projects_count(request.user)
    data['my_tickets_count'] = _get_user_tickets_count(request.user.username)

    return render_to_response('projects/search.html', 
                              {'data': data},
                              context_instance=RequestContext(request))

def tickets(request):
    data = {}
    ticket_set = _get_tickets(owner=request.user.username)
    data['tickets'] = ticket_set
    data['my_project_count'] = _get_user_projects_count(request.user)
    data['my_tickets_count'] = _get_user_tickets_count(request.user.username)
    return render_to_response('projects/tickets.html',
                              {'data': data},
                              context_instance=RequestContext(request))

def createprojectform(request):
    logging.debug(sys.path)
    data = {'my_project_count': 0}
    if request.method == 'POST':
        form = CreateProjectForm(request.POST)
        data['form'] = form
        if form.is_valid():
            name = form.cleaned_data['name']
            client = form.cleaned_data['client']
            display_name = form.cleaned_data['display_name']
            admins = form.cleaned_data['admins']
            type = form.cleaned_data['type']
            createsvn = form.cleaned_data['createsvn']
            svn_template = form.cleaned_data['svn_template']
            default_workspace = form.cleaned_data['default_workspace']
            usepostgres = form.cleaned_data['use_postgres']
            versioning_engine = form.cleaned_data['versioning_engine']
            tags = form.cleaned_data['tags']
            oforge = OForge(settings.OFORGE_CONFIGFILE)
            try:
                if not oforge_logger_initialized:
                    _init_oforge_logger()
                oforge.createproject(
                    name,
                    display_name=display_name,
                    admins=admins,
                    type=type,
                    createsvn=createsvn,
                    svntemplate=svn_template,
                    defaultworkspace=default_workspace,
                    postgres=usepostgres,
                    versioning_engine=versioning_engine,
                    tags=tags
                )
                new_proj = Project.objects.filter(name=name)[0]
                new_proj.client = client
                new_proj.save()
                for i in request.POST.items():
                    if i[0].startswith('custom_attribute_'):
                        attr_name = i[0].replace('custom_attribute_', '', 1)
                        new_proj.set_attribute(attr_name, i[1])
                flash = "Project <a href='/trac/%s'>%s</a> was created " \
                        "successfully."%(name, display_name)
                request.user.message_set.create(message=flash)
            except Exception, e:
                print >> sys.stderr, traceback.format_exc()
                request.user.message_set.create(message=("Error: %s"%(
                    e.message or 'unknown')))
                request.user.message_set.create(
                        message='An error occurred.  Please contact the " \
                                "System Administrator.')
            return HttpResponseRedirect(
                reverse('oforgetools.projects.views.createprojectform'))
    else:
        data['my_project_count'] = _get_user_projects_count(request.user)
        data['my_tickets_count'] = _get_user_tickets_count(
                request.user.username)
        defaults = settings.CREATE_PROJECT_DEFAULTS
        data['form'] = CreateProjectForm()
        data['defaults'] = {}
        if defaults.get('svntemplate', None):
            data['defaults']['svn_template'] = defaults.get('svntemplate') 
        if defaults.get('defaultworkspace', None):
            data['defaults']['default_workspace'] = \
                defaults.get('defaultworkspace') 
        if defaults.get('usepostgres', True):
            data['defaults']['use_postgres'] = defaults.get('usepostgres', 
                    True) 
    return render_to_response('projects/createproject.html', 
        {'data': data},
        context_instance=RequestContext(request))

def _init_oforge_logger():
    logger = logging.getLogger('OForge')
    logger.setLevel(logging.DEBUG)
    slh = handlers.SysLogHandler('/dev/log')
    slh.setLevel(logging.DEBUG)
    formatter = logging.Formatter("[%(name)s]: %(levelname)s: %(message)s")
    slh.setFormatter(formatter)
    logger.addHandler(slh)
    oforge_logger_initialized = True

def autocomplete(request):
    field = request.REQUEST.get('field')
    query = request.REQUEST.get('q')
    default = request.REQUEST.get('default')
    words = []
    if field == 'client':
        words = Project.objects.filter(client__icontains=query
                ).order_by('client').distinct().values_list(
                        'client', flat=True)
    elif field == 'display_name':
        words = Project.objects.filter(display_name__icontains=query
                ).order_by('display_name').distinct().values_list(
                        'display_name', flat=True)
    elif field == 'tags':
        matching_tags = Tag.objects.filter(name__icontains=query).order_by('name')
        words = [tag.name for tag in matching_tags]

    words_list = list(words)
    if default and default <> '' and re.match(query, default, re.IGNORECASE):
        words_list.append(default)
        words_list.sort()
    return HttpResponse(words_list and '\n'.join(words_list) or '')


def dashboard_select(request):
    id = request.REQUEST.get('id')
    selected = request.REQUEST.get('selected') == 'true'

    try:
        user_profile = OForgeProfileManager().get_user_profile(user=request.user)
        project = Project.objects.get(id=id)
        if selected:
            user_profile.dashboard_projects.add(project)
        else:
            user_profile.dashboard_projects.remove(project)
        user_profile.save()
    except:
        logging.warning("Problem updating user projects: %s", sys.exc_info()[0])
    
    return HttpResponse(cjson.encode({'my_project_count':user_profile.dashboard_projects.count()}))

def projects_json(request):
    user_projects=[]
    try:
        user_profile = OForgeProfileManager().get_user_profile(user=request.user)
        user_projects = user_profile.dashboard_projects.all()
    except:
        logging.warning("Problem loading user projects: %s", sys.exc_info()[0])

    page = _get_projects_by_request(request)
    data = {
        'page': page.number,
        'total': page.paginator.num_pages,
        'records': page.paginator.count
    }
    
    rows = []    
    for project in page.object_list:
        p = {}
        p['id'] = project.id
        p['url'] = project.url()
        p['type'] = project.type
        p['state'] = project.state
        p['dashboard'] = project in user_projects and 'true' or 'false'
        p['name'] = project.name
        p['client'] = project.client
        p['display_name'] = project.display_name
        p['start_date'] = str(project.start_date.date())
        p['end_date'] = str(project.end_date or '')
        for attr in project.customprojectattributes_set.values():
            p['custom_attribute_%s'%(attr['name'])] = attr['value'] or ''
        p['tags'] = ', '.join([tag.name for tag in project.tags])
        rows.append(p)
    data['rows'] = rows
    return HttpResponse(cjson.encode(data))

def _get_tickets(page=1, rp=50, sortname='project', sortorder='acs',
        owner=None):
    ticket_set = Ticket.objects.exclude(status='closed')
    if owner:
        ticket_set = ticket_set.filter(owner=owner)
    return ticket_set

def _get_projects(page=1, rp=50, sortname='display_name', sortorder='asc', 
         display_name=None, type=None, state=None, client=None,
        tags=None, user=None, dashboard=None, 
        start_date_range=None):
    
    project_set = Project.objects
    project_set = project_set.exclude(type='hidden')

    if dashboard:
        project_set = OForgeProfileManager().get_user_profile(user=user).dashboard_projects.all()
    else:
        if tags and len(tags):
                # FIXME: appears to still be getting UNION rather than INTERSECTION
            project_set=TaggedItem.objects.get_intersection_by_model(Project, tags)
        if client and client <> '':
            project_set = project_set.filter(client__icontains=client)
        if display_name and display_name <> '':
            project_set = project_set.filter(display_name__icontains=display_name)
        if type and type <> '':
            project_set = project_set.filter(type=type)
        if state and state <> '':
            project_set = project_set.filter(state=state)
        if start_date_range:
            project_set = project_set.filter(start_date__gt=start_date_range[0]).\
                filter(start_date__lt=start_date_range[1])

    if Project._meta.get_all_field_names().__contains__(sortname):
        order_by = "%s%s"%(sortorder == 'desc' and '-' or '', sortname)
        project_set = project_set.order_by(order_by)

    paginator = Paginator(project_set, rp)
    return paginator.page(page)

def _get_projects_by_request(request):
    dashboard = request.REQUEST.get('myprojects', None)
    client = request.REQUEST.get('client', None)
    display_name = request.REQUEST.get('display_name', None)
    type = request.REQUEST.get('type', None)
    state = request.REQUEST.get('state', 'Open')
    if state == 'All':
        state = None
    tags = request.REQUEST.get('tags', None)
    page = request.REQUEST.get('page', 1)
    rp = request.REQUEST.get('rows', 50)
    sortname = request.REQUEST.get('sidx', 'display_name')
    sortorder = request.REQUEST.get('sord', None)
    start_date_range_string = request.REQUEST.get('start_date_range', None)
    start_date_range = None
    if start_date_range_string and start_date_range_string <> '':
        SDRre = '^(\d{2}/\d{2}/\d{4})\s-\s(\d{2}/\d{2}/\d{4})$'
        match = re.match(SDRre, start_date_range_string)
        if match:
            start_date_range = match.groups()
    return _get_projects(page=int(page), rp=int(rp), 
            sortname=sortname, sortorder=sortorder, client=client,
            display_name=display_name, type=type, state=state,
            tags=tags, user=request.user, dashboard=dashboard, 
            start_date_range=start_date_range)

def _get_user_projects_count(user):
    user_profile = OForgeProfileManager().get_user_profile(user)
    return user_profile.dashboard_projects.count()

def _get_user_tickets_count(username):
    return Ticket.objects.exclude(status='closed').filter(owner=username).count()

def _get_featured_projects():
    return {
       'featured':TaggedItem.objects.get_intersection_by_model(Project, 'featured')[:4],
       'latest': Project.objects.order_by('start_date')[:4],
       'popular':TaggedItem.objects.get_intersection_by_model(Project, 'popular')[:4],
       'resource':TaggedItem.objects.get_intersection_by_model(Project, 'resource')[:4],
       }