Exemplo n.º 1
0
def zrodlo(request, case_id, event_id):

  template = loader.get_template("edycja_zrodla.html")
  
  class RefForm (forms.Form):
    art_title = forms.CharField(label=u'Tytul artykulu', required=False)
    pub_title = forms.CharField(label=u'Tytul publikacji', required=False)
    url = forms.CharField(label=u'URL', required=False)
    pub_date = forms.DateField(label='Data publikacji', widget=SelectDateWidget(years=range(1989, 2020)),required=False)
    access_date = forms.DateField(label='Data dostepu', widget=SelectDateWidget(years=range(1989, 2020)))

  if request.method == 'GET':
    ref_form=RefForm()
      
  elif request.method == 'POST':
    ref_form = RefForm(request.POST)
    if ref_form.is_valid():
      data = [ ref_form.cleaned_data[item] for item in ('art_title', 'pub_title', 'url', 'pub_date', 'access_date') ]
      try:
        event_refs=list(orm.query('event_refs', event_id)[0][0][0])
      except (TypeError, IndexError):
        event_refs=[]
      ref_id=orm.query('create_ref', data)[0]
      event_refs.append(ref_id)
      orm.query('update_event_refs', (event_refs, event_id))
      return HTTPResponseRedirect(reverse('edytor.views.wydarzenie', kwargs=dict(event_id=event_id, case_id=case_id)))

  return HTTPResponse(template.render(RequestContext(request, dict(form=ref_form)))) 
Exemplo n.º 2
0
def actor (request, object_id):

  actor = orm.query('actor', object_id)[0]

  roles_rows = orm.query('actor_roles', object_id)

  roles_dict = {}
  for row in roles_rows:
    role = row[1]
    case = row[3]
    role_dict = roles_dict.get(role,dict(id=row[0]))
    case_list = role_dict.get(case, [])
    case_list.append(row[2])
    role_dict[case] = case_list
    roles_dict[role] = role_dict
    
  roles = [ ( role, [ ((case, roles_dict[role]['id']), roles_dict[role][case]) for case in roles_dict[role].keys() if not case=='id' ] ) for role in roles_dict.keys() ]
  
  human = actor[2]
  
  if human:
    related = []
  else:
    related = orm.query('related_human_actors', object_id)
    
  result = dict(actor=actor, roles=roles, tab=2 if human else 3, human=human, related=related)

  template = loader.get_template("aktor.html")

  return HTTPResponse (template.render(Context(result)))
Exemplo n.º 3
0
def atrybut(request, case_id=None, event_id=None, actor_id=None):

  case_attributes = {'scandal_types':'Typ', 'scandal_field': 'Sfera dotknięta korupcją'}
  class CaseForm(forms.Form):
    attribute = forms.ChoiceField(choices=[(key, case_attributes[key]) for key in case_attributes.keys()],
      label="Wybierz atrybut")
    name = forms.CharField(label="Nazwa")
   
  event_attributes = {'event_types': 'Typ wydarzenia'}
  class EventForm(forms.Form):
    attribute = forms.ChoiceField(choices=[(key, event_attributes[key]) for key in event_attributes.keys()],label="Wybierz atrybut")
    name = forms.CharField(label="Nazwa")
    
  actor_attributes = {'secondary_affiliations': 'Afiliacja drugorzędna', 
    'actor_affiliations': 'Afiliacja','actor_roles':'Rola', 'actor_types': 'Typ'}
  class ActorForm(forms.Form):
    attribute = forms.ChoiceField(choices=[(key, actor_attributes[key]) for key in actor_attributes.keys()],label="Wybierz atrybut")          
    name = forms.CharField(label="Nazwa")    
    human = forms.BooleanField(label="Osoba", required=False)
  
  if actor_id:
    form=ActorForm
    if actor_id=='0':
      back = reverse('edytor.views.wydarzenie', kwargs=dict(case_id=case_id, event_id=event_id)    )
    else:  
      back = reverse('edytor.views.aktor', kwargs=dict(case_id=case_id, event_id=event_id, actor_id=actor_id))
  elif event_id:
    form=EventForm
    back = reverse('edytor.views.wydarzenie', kwargs=dict(case_id=case_id, event_id=event_id)    )
  elif case_id:
    form=CaseForm           
    back = reverse('edytor.views.afera', kwargs=dict(case_id=case_id))

  template=loader.get_template("atrybut.html")

  if request.method=='GET':
    attribute_form = form()  

  elif request.method == 'POST':

    attribute_form = form(request.POST)
    if attribute_form.is_valid():
      table = attribute_form.cleaned_data['attribute']
      name  = attribute_form.cleaned_data['name']
      
      if isinstance(attribute_form, ActorForm):
        data = (table, name,  attribute_form.cleaned_data['human'])
        orm.query('create_attribute_human', data, special=True)        
      else:
        data = (table, name)
        orm.query('create_attribute', data, special=True)      

      return HTTPResponseRedirect(back)
  return HTTPResponse(template.render(RequestContext(request, dict(form=attribute_form,
    event_id=event_id, actor_id=actor_id, case_id=case_id))))
Exemplo n.º 4
0
def api_case_json(request, object_id, major=False):

  import json

  case = get_scandal(object_id)
  events = orm.query('case_events', (object_id, True if major else False))
  
  result = {}

  result['timeline'] = { 'headline': case[0][0][0], 'type': 'default', 'start_zoom_adjust': 40, 'start_at_slide': 1,
    'text': case[0][1], 'startDate': events[0][1].strftime('%Y,%m,%d') if events else '1970,01,01' }


  dates = []

  if events:
    for event in events:
      actors = orm.query('event_actors', event[0])
      refs = orm.query('full_event_refs', event[0])
      text = ''
      for t in event[2].split('\n'):
        text = text + '<p>' + t + '</p>'
      if actors: 
        text = text + '<p class="timeline-aktorzy">Aktorzy wydarzenia:<ul>'
        for actor in actors:
          text = text + '<li><a href="/podmiot/%s/">%s</a></li>' % (actor[0], actor[1])
        text = text + '</ul>'
      if refs: 
        text = text + '<p class="timeline-refs">Bibliografia:<ul>'
        for ref in refs:
          if ref[4]:
            if ref[2]:
              text = text + '<li><a href="%s" target="_blank">%s %s.%s.%s: %s</a></li>' % (ref[4], ref[1], ref[2].day, ref[2].month, ref[2].year, ref[0])                    
            else:
              text = text + '<li><a href="%s" target="_blank">%s: %s</a></li>' % (ref[4], ref[1], ref[0])
          else:
            if ref[2]:
              text = text + '<li>%s %s.%s.%s: %s</li>' % (ref[1], ref[2].day, ref[2].month, ref[2].year, ref[0])          
            else:
              text = text + '<li>%s: %s</li>' % (ref[1], ref[0])
        text = text + '</ul>'
      dates.append({'startDate': event[1].strftime('%Y,%m,%d'), 
        'endDate': event[1].strftime('%Y,%m,%d'), 'headline':event[6], 'text': text, 
        'start_at_slide': 1, 'start_zoom_adjust': -15})

  result['timeline']['date']=dates

  return HTTPResponse(json.dumps(result))
Exemplo n.º 5
0
def event (request, object_id):

  actors = orm.query('event_actors', object_id)
  
  template = loader.get_template("aktorzy_wydarzenuia.inc")

  return HTTPRequest (template.render(Context(dict(event=[None, actors]))))
Exemplo n.º 6
0
def aktorzy(request):

  template = loader.get_template('aktorzy.html')
  
  actors = orm.query('all_actors')

  return HTTPResponse(template.render(RequestContext(request, dict(actors=actors))))
Exemplo n.º 7
0
def case_actors (request, object_id):
  'returns HTML <ul> for case actors'
  
  result = {}
  result['actors'] = orm.query('case_actors', object_id)
  template = loader.get_template("aktorzy.inc")
  return HTTPResponse (template.render(Context(dict(case=result))))
Exemplo n.º 8
0
def timeline(request, object_id):
  'single scandal timeline view'

  result = {}
  scandal = get_scandal(object_id)
  result['name'] = scandal [0][0][0]
  result['names'] = scandal [0][0][1:]
  result['description'] = scandal [0][1]
  result['background'] = scandal[0][2]
  result['case'] = object_id
  result['all_actors'] = orm.query('case_actors', object_id)
  result['fields'] = orm.query('scandal_fields', object_id)
  result['types'] = orm.query('scandal_types', object_id)
  result['case_id'] = object_id
  result['num_events'] = len(scandal[0][3])
  result['tab'] = 1
    
  template = loader.get_template ('linia.html')

  return HTTPResponse (template.render(Context(result))  )
Exemplo n.º 9
0
def case (request, object_id):

  'single scandal view'
  
  scandal = get_scandal(object_id)
  events = orm.query('case_events', object_id)

  if events:
    ujawnienie_actors = orm.query('event_actors',events[0][0])
    ujawnienie = (events[0], ujawnienie_actors[:5],len(ujawnienie_actors))

  else:
    ujawnienie = (None, None, None)
    
  result = {} 
  
  result['name'] = scandal [0][0][0]
  result['names'] = scandal [0][0][1:]
  result['description'] = scandal [0][1]
  result['background'] = scandal[0][2]
  result['num_events'] = len(events)
  result['event_leak'] = ujawnienie
  result['events'] = [ (e, orm.query('event_actors', e[0])[:6]  )
                       for e in events[1:]]
   
  result['javascripts'] = ['actors']
  result['all_actors'] = orm.query('case_actors', object_id)
  result['tab'] = '1'
  result['fields'] = orm.query('scandal_fields', object_id)
  result['types'] = orm.query('scandal_types', object_id)
  
  template = loader.get_template ('afera.html')

  return HTTPResponse (template.render(Context(result))  )
Exemplo n.º 10
0
def event (request, object_id):
  'single event view'
  scandal_title = None  
  event = list(orm.query('event', object_id)[0])
  actors = orm.query('event_actors', object_id)  
  event[2] = event[2].split('\n')
  
  scandal_title = orm.query('event_case_title', event[0])[0][0][0]
  
  try:
    if event:
      refs = orm.query('refs','{'+','.join([str(i) for i in event[5]])+'}')
  except (IndexError, TypeError):
    refs = []

  try: 
    prev_e = orm.query('prev_event', (object_id, object_id))[0]
  except IndexError:
    prev_e = None
  try:
    next_e = orm.query('next_event', (object_id,object_id))[0]
  except IndexError:
    next_e = None
                      
  result = dict(refs=refs, event=event, prev=prev_e, next=next_e, actors=actors,tab=1)

  result['tab'] = 1
  result['scandal_title'] = scandal_title if isinstance(scandal_title, unicode) else scandal_title.decode('utf-8')

  template = loader.get_template("wydarzenie.html")

  return HTTPResponse (template.render(Context(result)))
Exemplo n.º 11
0
def szukaj (request):

  result = dict(form=SearchForm())
  if request.method == 'POST':    
    form = SearchForm(request.POST)
    if form.is_valid():
    
      term = form.cleaned_data.get('term', '').strip()
      
      if term:
        t = '%' + term + '%'
        result['cases'] = orm.query('search_cases', (t, t))
        result['events'] = orm.query('search_events', (t, t))
        result['actors'] = orm.query('search_actors', t)
        result['form'] = form

  template = loader.get_template("wyniki.html")      
  return HTTPResponse(template.render(RequestContext(request, result)))
    
      
  
    
Exemplo n.º 12
0
def actors (request, human=True):

  'Actors index.'

  result = []

  if human: 

    letters = [ l if isinstance(l, unicode) else l.decode('utf-8') for l in orm.query('letters')[0][0]]

    for l in letters:
      result.append((l, orm.query('actors_human_like', (l.lower()+'%', l.upper()+'%'))))
      
    template = loader.get_template("indeks.html")

  else:

    actors = orm.query('nonhuman_actor_list')
    actors_dict = {}

    for row in actors:
      group = actors_dict.get(row[2], [])
      group.append(row[:2])
      actors_dict[row[2]] = group

    #  print actors_dict

    keys = actors_dict.keys()
    keys.sort()

    for k in keys:
      actors = actors_dict[k]
      actors.sort(key=lambda a:a[1].lower())
      result.append((k, actors))

    template = loader.get_template("instytucje.html")

  return HTTPResponse (template.render(Context(dict(letters=result,tab=2 if human else 3))))
Exemplo n.º 13
0
def wydarzenie (request, case_id, event_id=None):

  locations = orm.query('locations')
  
  class EventForm (forms.Form):
    types = forms.ChoiceField(orm.query('events_types'))
    title = forms.CharField(label=u'Tytul')
    description = forms.CharField(label='Opis', widget=forms.Textarea())
#    publication_date = forms.DateField(label='Data publikacji', widget=SelectDateWidget(years=range(1989, 2014)), required=False)
    event_date = forms.DateField(label='Data wydarzenia', widget=SelectDateWidget(years=range(1989,2020)))
    major = forms.BooleanField(label="Wazne", required=False)
    descriptive_date = forms.CharField(label='Data opisowa', required=False)

  if request.method == "GET":

    if event_id:
      event = orm.query('event',event_id)
    
      try: 
        if event[0][0]:
          event=event[0]
          initial = dict(title=event[6], description=event[2], event_date=event[1], descriptive_date=event[8], types=event[9])
          event_form = EventForm (initial=initial)  
        else:
          event_form = EventForm()
      except IndexError:
        event_form = EventForm()
    else:
      event_form = EventForm()

    template = loader.get_template('edycja_wydarzenia.html')
    return HTTPResponse(template.render(RequestContext(request, dict(form=event_form, event_id=event_id, case_id=case_id))))
    
  elif request.method =="POST":
  
    event_form = EventForm(request.POST)

    if event_form.is_valid():
      data = [ [int(event_form.cleaned_data[index])] if index=='types' else event_form.cleaned_data[index] 
        for index in ('title', 'types', 'description', 'event_date', 'major', 'descriptive_date')]

      if event_id:      
        data.append(str(event_id))
        result = orm.query('update_event', data)
      else:
        event_id = orm.query('create_event', data)[0][0]
        events = orm.query('case_events_list',int(case_id))[0][0]        
        if not events:
          events = []
        events.append(int(event_id))        
        status = orm.query('case_update_events', (events, case_id))
                
      return HTTPResponseRedirect('/edit/%s/event/%s' % ( case_id, event_id))
    else:
      template = loader.get_template('edycja_wydarzenia.html')
      return HTTPResponse(template.render(RequestContext(request, dict(form=event_form))))
Exemplo n.º 14
0
def powiazane (request,actor_id=None):

  template = loader.get_template ("powiazane.html")
  
  class RelatedForm(forms.Form):
    actor = forms.ChoiceField(choices=[ list(i) for i in orm.query('all_actors') ],
      label="Nazwa", widget=forms.RadioSelect())
    affiliation = forms.ChoiceField(choices=[ list(i) for i in orm.query('all_actor_affiliations')],
      label="Afiliacje",widget=forms.RadioSelect(attrs={'size': 24}), required=False)
    secondary_affiliations = forms.ChoiceField(choices=[ list(i) for i in orm.query('all_actor_secondary_affiliations')],
      label="Afiliacje drugorzedne",widget=forms.RadioSelect(attrs={'size': 24}), required=False)

  if request.method == "GET":
    return HTTPResponse (template.render(RequestContext(request, dict(form=RelatedForm()))))
  elif request.method == "POST":
  
    form = RelatedForm(request.POST)
    if form.is_valid():
      affiliation = form.cleaned_data.get("affiliation", None)
      secondary = form.cleaned_data.get("secondary_affiliations", None)
      orm.query('create_related', (form.cleaned_data["actor"], int(affiliation) if affiliation else None, int(secondary) if secondary else None))
      return  HTTPResponseRedirect(redirect_to=reverse('edytor.views.powiazane'))      
    else:
      return HTTPResponse(template.render(RequestContext(request, dict(form=actor_form))))
Exemplo n.º 15
0
def edycja_aktora(request, object_id):

  template = loader.get_template('edycja_aktora.html')

  class ActorForm(forms.Form):
    id = forms.IntegerField(label='id', widget=forms.HiddenInput)
    name = forms.CharField(label='Nazwa/nazwisko', widget=forms.TextInput(attrs=dict(size='64')))
    human = forms.BooleanField(label="Osoba", required=False)

  if request.method == 'POST':
  
    actor_form=ActorForm(request.POST)
    if actor_form.is_valid():
      orm.query('update_actor', (actor_form.cleaned_data['name'], actor_form.cleaned_data['human'], object_id))
      return  HTTPResponseRedirect(redirect_to=reverse('edytor.views.aktorzy'))
    else:
      return HTTPResponse(template.render(RequestContext(request, dict(form=actor_form, object_id=object_id))))          

  elif request.method == 'GET':
    actor = orm.query('actor', object_id)[0]
    initial = dict(id=actor[0], name=actor[1], human=actor[2])
    form = ActorForm(initial=initial)
    
    return HTTPResponse (template.render(RequestContext(request, dict(form=form))))
Exemplo n.º 16
0
def afera(request, case_id=None):

  template = loader.get_template('edycja_afery.html')

  fields = orm.query('case_types')
  types = orm.query('case_fields') 

  class ScandalForm(forms.Form):
  
    name = forms.CharField(label=u'Tytuly (oddzielone przecinkami)')
    description = forms.CharField(label='Opis', widget=forms.Textarea())
    background = forms.CharField(label='Tło', widget=forms.Textarea())
    types = forms.MultipleChoiceField(orm.query('case_types'), widget=forms.CheckboxSelectMultiple(attrs={'size': len(orm.query('case_types'))}),label="Typ")
    fields = forms.MultipleChoiceField(orm.query('case_fields'), widget=forms.CheckboxSelectMultiple(attrs={'size': len(orm.query('case_fields'))}), label="Sfera")
  
  if request.method == "GET":
  
    if case_id:
      case = orm.query('get_case', case_id)
      
      try: 
        if case[0][0]: #jest id
          case=case[0]
          case_form = ScandalForm(initial=dict(titles=','.join(case[1]), description=case[2], background=case[3]))
        else:
           case_form=ScandalForm()
      except IndexError:
        case_form=ScandalForm()
                 
    else:
      case_form=ScandalForm()
      
    return HTTPResponse(template.render(RequestContext(request, dict(form=case_form, case_id=case_id))))

  elif request.method == "POST":
    case_form = ScandalForm(request.POST)

    if case_form.is_valid():
      data = [ [ int(i) for i in case_form.cleaned_data[index] ] if index in ['types','fields'] else case_form.cleaned_data[index] 
        for index in ('name', 'description', 'background', 'types', 'fields')]
      
      data = [data[0].split(',')] + data[1:]

      if case_id:
        data.append(str(case_id))
        orm.query('update_case', data)  
      else:
        result=orm.query('create_case', data)[0][0]
        
      return HTTPResponseRedirect('/edit/%s' % result)
    else:

      return HTTPResponse(template.render(RequestContext(request, dict(form=case_form))))
Exemplo n.º 17
0
def cases (request, type_id=None, field_id=None, intro=False):
  'all cases view'

  if type_id and field_id:
    cases = orm.query('cases_type_field', (type_id, field_id))
  elif type_id:
    cases = orm.query('cases_type', type_id)
  elif field_id:
    cases = orm.query('cases_field', field_id)
  else:
    cases = orm.query('cases')

  types =  [ (typ[0], [ t for t in typ[1].split('/') if t]) for typ in orm.query('case_types') ]
  fields = [ (field[0], [ t for t in field[1].split('/') if t]) for field in orm.query('case_fields') ]
  result = []

  ## TODO ustawianie id=active dla wybranych fieldow i typow

  for c in cases:

    case = dict(id=c[0],title=c[1], description=c[2])
    actors = orm.query('case_actors', c[0])
    case['events'] = orm.query('event_count', c[0])[0][0]
    case['actors'] = actors[:5]
    if actors:
      case['num_actors'] = len(actors)
    else: 
      case['num_actors'] = 0
    try:
      case['num_events'] = len(c[7])
    except (TypeError, IndexError):
      case['num_events'] = 0
    result.append(case)

  template = loader.get_template ('afery.html')

  return HTTPResponse (template.render(Context(dict(cases=result,intro=intro,
    tab=1, javascripts=['actors', 'jquery-1.9.1.min', 'hide'], jquery=True, types=types, fields=fields, type_id=type_id, field_id=field_id))))
Exemplo n.º 18
0
def aktor(request, case_id, event_id, actor_id=None, add=False):

  template = loader.get_template('edycja_aktora.html')
  
  class ActorForm(forms.Form):
    actor = forms.ChoiceField(choices=[ list(i) for i in orm.query('all_actors') ], 
      label="Nazwa", widget=forms.RadioSelect())    

  class AddActorForm(forms.Form):
    name = forms.CharField(label='Nazwa/nazwisko')
    human = forms.BooleanField(label="Osoba", required=False)
    
  class EventActorForm(forms.Form):
    types = forms.MultipleChoiceField(choices=[ list(i) for i in orm.query('all_actor_types') ],
      widget=forms.CheckboxSelectMultiple(attrs={'size': 24}), label="Typy", required=False)
    roles = forms.ChoiceField(choices=orm.query('all_actor_roles'), label="Role", required=False)
    primary = forms.BooleanField(default=True)
    affiliations = forms.MultipleChoiceField(choices=[ list(i) for i in orm.query('all_actor_affiliations')],
      label="Afiliacje",widget=forms.CheckboxSelectMultiple(attrs={'size': 24}), required=False)
    secondary = forms.BooleanField(default=True)
    secondary_affiliations = forms.MultipleChoiceField(choices=[ list(i) for i in orm.query('all_actor_secondary_affiliations')],
      label="Afiliacje drugorzedne",widget=forms.CheckboxSelectMultiple(attrs={'size': 24}), required=False)
    
  if request.method == "GET":
 
   if actor_id:
   # mamy wybranego aktora
   # todo uzupelnianie zaznaczen TODO
   
     metadata = orm.query('case_actor_events_metadata', (case_id, actor_id))
     if metadata:
       line = metadata[-1]
     
       cols = ('types','roles', 'affiliations', 'secondary_affiliations') 
       metadata_dict = {}
#    for line in metadata:
       for item in cols:
         workset = metadata_dict.get(item,set())
         l = line[cols.index(item)]
         if l:
           workset = workset.union(tuple(l))
         metadata_dict[item] = workset
              
       output = {}
       for item in cols:
         workdict = {}
         workset = metadata_dict.get(item,set())
         for val in workset:
           if item == 'roles':
             output[item] = str(val)
           else:
             workdict[val] = 'checked'
             output[item] = workdict
#       'abc'[10]
       actor_form = EventActorForm(initial=output)
     else:
       actor_form = EventActorForm()

     return HTTPResponse(template.render(RequestContext(request, dict(form=actor_form, event_id=event_id, case_id=case_id))))
   else:
     if add:
       # dodajemy aktora
       return HTTPResponse(template.render(RequestContext(request, dict(form=AddActorForm(), event_id=event_id, case_id=case_id))))
     else:
       # wybieramy aktora
       return HTTPResponse(template.render(RequestContext(request, dict(form=ActorForm(), event_id=event_id, case_id=case_id))))
  elif request.method == "POST":
    if actor_id: 
    # wybralismy aktora i albo pokazujemy formatke albo go przypisujemy
      actor_form = EventActorForm(request.POST)
    
      if actor_form.is_valid():
        data = [ [int(i) for i in actor_form.cleaned_data[index]] if index in ['types', 'roles', 'affiliations', 'secondary_affiliations']  else actor_form.cleaned_data[index]
          for index in ('types', 'roles', 'affiliations', 'secondary_affiliations', 'primary', 'secondary')]
        
        data = [event_id, actor_id] + data
        orm.query('assign_actor', data)
        
        return  HTTPResponseRedirect(redirect_to=reverse('edytor.views.wydarzenie', 
          kwargs=dict(event_id=event_id, case_id=case_id)))
      else: 
        #cos nie pasuje, pokazujemy form jeszcze raz TODO
        return HTTPResponse(template.render(RequestContext(request, dict(form=actor_form, event_id=event_id, case_id=case_id, actor_id=actor_id))))   
    else: 
      if add == True:
        add_actor_form=AddActorForm(request.POST)
        if add_actor_form.is_valid():
          actor_id = orm.query('create_actor', (add_actor_form.cleaned_data['name'], add_actor_form.cleaned_data['human']))[0][0]
          return  HTTPResponseRedirect(redirect_to=reverse('edytor.views.aktor', 
            kwargs=dict(event_id=event_id, case_id=case_id, actor_id=actor_id)))        
        else:
          return HTTPResponse(template.render(RequestContext(request, dict(form=add_actor_form, event_id=event_id, case_id=case_id))))          
      else:
        actor_form = ActorForm(request.POST)
        if actor_form.is_valid():
        # nie mamy actor_id, albo pokazujemy formatke, albo przekierowujemy do actor_id
          actor_id = actor_form.cleaned_data["actor"]
          return  HTTPResponseRedirect(redirect_to=reverse('edytor.views.aktor', 
            kwargs=dict(event_id=event_id, case_id=case_id, actor_id=actor_id)))        
        else:
          return HTTPResponse(template.render(RequestContext(request, dict(form=actor_form))))
Exemplo n.º 19
0
def lista(request):
  template=loader.get_template("lista_afer.html")
  cases = orm.query("cases")
  return HTTPResponse(template.render(RequestContext(request, dict(cases=cases))))