Semantics for nouns: fixes for payments, validation, and others.

Bartłomiej Nitoń
1 parent c13a529a
Showing 11 changed files with 131 additions and 72 deletions
accounts/models.py
dictionary/ajax_lemma_status.py
dictionary/ajax_lemma_view.py
dictionary/ajax_user_stats.py
dictionary/models.py
dictionary/saving.py
dictionary/static/js/lemma-view.js
dictionary/templates/sel_user_stats.html
semantics/management/commands/find_hanging_connections.py
semantics/validation.py
semantics/views.py
@@ -279,6 +279,9 @@ class RealizedSemantics(Model):
     # wykonane ramki (wypelniane dla semantyka)
     made_frames = PositiveIntegerField(db_column='wykonane_ramki',
                                        default=0)
+    # wspoldzielone ramki (wypelniane dla semantyka)
+    related_frames = PositiveIntegerField(db_column='wspoldzielone_ramki',
+                                          default=0)
     # poprawione ramki (wypelniane dla supersemantyka)
     corr_frames = PositiveIntegerField(db_column='poprawione_ramki',
                                        default=0)
@@ -117,10 +117,10 @@ def lemma_status_change(request, status_id, lemma_id):
        not lemma_obj.status.next_statuses.filter(pk=new_status.pk).exists()):
         raise AjaxError('wrong change')
  
-    actual_semantic_frames = SemanticFrame.objects.none()
+    visible_semantic_frames = SemanticFrame.objects.none()
     next_status = False
     if(new_status):
-        actual_semantic_frames = backup_lemma_and_get_frames(lemma_obj)
+        visible_semantic_frames = backup_lemma_and_get_frames(lemma_obj)
  
     if(new_status and new_status.priority > lemma_obj.status.priority):
         next_status = True
@@ -223,8 +223,10 @@ def lemma_status_change(request, status_id, lemma_id):
          and next_status):
         ### naliczanie oplat za gotowosc semantyczna
         frame_value = 12.0
-        update_sem_stats_ready_s(lemma_obj.entry_obj, actual_semantic_frames, 
-                                 lemma_obj.semanticist, new_status, frame_value)
+        related_frame_value = 2.0
+        update_sem_stats_ready_s(lemma_obj.entry_obj, visible_semantic_frames,
+                                 lemma_obj.semanticist, new_status, frame_value,
+                                 related_frame_value)
         add_new_frames_to_phraseologic_propositions(lemma_obj)
         changed = True
     # zmiana statusu hasla na sprawdzone semantycznie
@@ -236,8 +238,8 @@ def lemma_status_change(request, status_id, lemma_id):
         part_bonus = 2.0
         connection_bonus = 0.1
         ### naliczanie oplat za sprawdzenie i bonusow
-        update_sem_stats_conf_s(entry=lemma_obj.entry_obj, 
-                                semantic_frames=actual_semantic_frames, 
+        update_sem_stats_conf_s(entry=lemma_obj.entry_obj,
+                                checked_sem_frames_backup=visible_semantic_frames,
                                 semanticist=lemma_obj.semanticist, 
                                 supersemanticist=request.user, 
                                 status=new_status,
@@ -273,7 +275,7 @@ def lemma_status_change(request, status_id, lemma_id):
                                      lemma=lemma_obj,
                                      status=new_status)
         status_change.save()
-        status_change.semantic_frames.add(*actual_semantic_frames.all())
+        status_change.semantic_frames.add(*visible_semantic_frames.all())
         lemma_obj.status_history.add(status_change)    
  
     if new_status:
@@ -472,45 +474,59 @@ def update_lemma_stats_conf_f(lemma, phraseologist, superphraseologist, status,
     phraseologist.user_stats.phraseology_real_history.add(phraseologist_real_lemma)
  
 ####################### semantics #############################     
-def update_sem_stats_ready_s(entry, semantic_frames, semanticist, status, frame_value):
-    actual_frames_count = semantic_frames.count()
-    sem_dict = {'made_frames': actual_frames_count,
-                'cash': frame_value*float(actual_frames_count)}
+def update_sem_stats_ready_s(entry, visible_semantic_frames, semanticist, status,
+                             frame_value, related_frame_value):
+    actual_frames = entry.actual_frames()
+    actual_frames_count = actual_frames.count()
  
-    realized_semantics = RealizedSemantics(entry=entry, cash=sem_dict['cash'],
-                                           made_frames=sem_dict['made_frames'],
+    related_frames = entry.related_frames()
+    related_frames_count = related_frames.count()
+
+    cash = frame_value*float(actual_frames_count) + related_frame_value*float(related_frames_count)
+
+
+    realized_semantics = RealizedSemantics(entry=entry, cash=cash,
+                                           made_frames=actual_frames_count,
+                                           related_frames=related_frames_count,
                                            status=status, bonus=False)
     realized_semantics.save()
-    realized_semantics.frames.add(*semantic_frames.all())
+    realized_semantics.frames.add(*visible_semantic_frames.all())
     semanticist.user_stats.semantics_real_history.add(realized_semantics)
  
-def update_sem_stats_conf_s(entry, semantic_frames, semanticist, supersemanticist, status,
-                               checked_frame_value, corrected_frame_value, 
-                               bonus_factor, part_bonus_factor, connection_bonus):
+def update_sem_stats_conf_s(entry, checked_sem_frames_backup, semanticist, supersemanticist, status,
+                            checked_frame_value, corrected_frame_value,
+                            bonus_factor, part_bonus_factor, connection_bonus):
     ready_statuses = Lemma_Status.objects.filter(type__sym_name='ready_s')
     q_ready_statuses = [Q(status=ready_status) for ready_status in ready_statuses.all()]
  
     ready_semantics = RealizedSemantics.objects.filter(reduce(operator.or_, q_ready_statuses))
-    ready_sem_frames= ready_semantics.get(entry=entry).frames
-    checked_sem_frames = semantic_frames
-    ready_to_checked_diffs = get_frames_differences(ready_sem_frames.all(), checked_sem_frames.all())
-    checked_to_ready_diffs = get_frames_differences(checked_sem_frames.all(), ready_sem_frames.all())
+    ready_sem_visible_frames = ready_semantics.get(entry=entry).frames
+    ready_sem_actual_frames = entry.filter_local(ready_sem_visible_frames)
+    ready_sem_related_frames = entry.filter_related(ready_sem_visible_frames)
+
+    checked_sem_actual_frames = entry.actual_frames()
+    checked_sem_related_frames = entry.related_frames()
+
+    actual_ready_to_checked_diffs = get_frames_differences(ready_sem_actual_frames.all(), checked_sem_actual_frames.all())
+    actual_checked_to_ready_diffs = get_frames_differences(checked_sem_actual_frames.all(), ready_sem_actual_frames.all())
+
+    visible_ready_to_checked_diffs = get_frames_differences(ready_sem_visible_frames.all(), checked_sem_frames_backup.all())
  
-    connections_amount = count_connections(ready_to_checked_diffs)
-    sem_cash = (bonus_factor*float(len(ready_to_checked_diffs['matching_frames'])) +
-                part_bonus_factor*float(len(ready_to_checked_diffs['part_matching_frames'])) +
+    connections_amount = count_connections(entry, visible_ready_to_checked_diffs)
+    sem_cash = (bonus_factor*float(len(actual_ready_to_checked_diffs['matching_frames'])) +
+                part_bonus_factor*float(len(actual_ready_to_checked_diffs['part_matching_frames'])) +
                 connection_bonus*float(connections_amount))
-    sem_dict = {'same_frames': len(ready_to_checked_diffs['matching_frames']),
-                'part_same_frames': len(ready_to_checked_diffs['part_matching_frames']),
-                'wrong_frames': len(ready_to_checked_diffs['missing_frames']),
+    sem_dict = {'same_frames': len(actual_ready_to_checked_diffs['matching_frames']),
+                'part_same_frames': len(actual_ready_to_checked_diffs['part_matching_frames']),
+                'wrong_frames': len(actual_ready_to_checked_diffs['missing_frames']),
                 'added_connections': connections_amount,
                 'cash': sem_cash}
  
-    supersem_cash = (float(len(checked_to_ready_diffs['missing_frames'])+len(checked_to_ready_diffs['part_matching_frames']))*corrected_frame_value +
-                     float(len(ready_to_checked_diffs['matching_frames']))*checked_frame_value)
-    supersem_dict = {'same_frames': len(checked_to_ready_diffs['matching_frames']),
-                     'part_same_frames': len(checked_to_ready_diffs['part_matching_frames']),
-                     'redo_frames': len(checked_to_ready_diffs['missing_frames']),
+    supersem_cash = (float(len(actual_checked_to_ready_diffs['missing_frames'])+len(actual_checked_to_ready_diffs['part_matching_frames']))*corrected_frame_value +
+                     float(len(actual_ready_to_checked_diffs['matching_frames']))*checked_frame_value)
+    supersem_dict = {'same_frames': len(actual_checked_to_ready_diffs['matching_frames']),
+                     'part_same_frames': len(actual_checked_to_ready_diffs['part_matching_frames']),
+                     'redo_frames': len(actual_checked_to_ready_diffs['missing_frames']),
                      'cash': supersem_cash}
  
     supersem_real_semantics = RealizedSemantics(entry=entry, 
@@ -521,7 +537,7 @@ def update_sem_stats_conf_s(entry, semantic_frames, semanticist, supersemanticis
                                                 status=status, 
                                                 bonus=False)
     supersem_real_semantics.save()
-    supersem_real_semantics.frames.add(*semantic_frames.all())
+    supersem_real_semantics.frames.add(*checked_sem_frames_backup.all())
     supersemanticist.user_stats.semantics_real_history.add(supersem_real_semantics)
  
     sem_real_semantics = RealizedSemantics(entry=entry, 
@@ -533,15 +549,16 @@ def update_sem_stats_conf_s(entry, semantic_frames, semanticist, supersemanticis
                                            status=status,
                                            bonus=True)
     sem_real_semantics.save()
-    sem_real_semantics.frames.add(*semantic_frames.all())
+    sem_real_semantics.frames.add(*checked_sem_frames_backup.all())
     semanticist.user_stats.semantics_real_history.add(sem_real_semantics)
  
-def count_connections(differences):
-    amount = 0 
+def count_connections(entry, differences):
+    amount = 0
+    schemata = entry.actual_schemata()
     for frame in differences['matching_frames']:
-        amount += frame.connected_schemata().count()
+        amount += frame.connected_schemata().filter(pk__in=schemata).count()
     for frame in differences['part_matching_frames']:
-        amount += frame.connected_schemata().count()
+        amount += frame.connected_schemata().filter(pk__in=schemata).count()
     return amount
  
 def remove_semantic_payments(entry):
@@ -830,12 +830,24 @@ def disrelate_entries(request, lemma_id, preview_lemma_id):
     error, lemma, preview_lemma = check_if_selected_and_get(lemma_id, preview_lemma_id)
     if not error:
         error = check_if_has_rights_to_relate(lemma, request.user)
+    if not error:
+        error = check_if_share_sematic_frames(lemma, preview_lemma)
     if error:
         raise AjaxError(error)
     else:
         cancel_entries_relation(request, lemma, preview_lemma)
     return {}
  
+def check_if_share_sematic_frames(lemma, preview_lemma):
+    error = ''
+    lemma_visible_frames = lemma.entry_obj.visible_frames()
+    preview_visible_frames = preview_lemma.entry_obj.visible_frames()
+
+    if (lemma_visible_frames.filter(pk__in=preview_visible_frames).exists() or
+        preview_visible_frames.filter(pk__in=lemma_visible_frames).exists()):
+        error = 'shared frames'
+    return error
+
 def cancel_entries_relation(request, lemma, preview_lemma):
     lemma_entry, preview_lemma_entry = get_entries(lemma, preview_lemma)
     lemma_entry.rel_entries.remove(preview_lemma_entry)
@@ -239,6 +239,9 @@ def get_semantics_stats(user):
     ncorr_frames = RealizedSemantics.objects.filter(user_stats__user=user).aggregate(Sum('ncorr_frames'))['ncorr_frames__sum']
     if ncorr_frames == None:
         ncorr_frames = 0
+    related_frames = RealizedSemantics.objects.filter(user_stats__user=user).aggregate(Sum('related_frames'))['related_frames__sum']
+    if related_frames == None:
+        related_frames = 0
     made_frames = RealizedSemantics.objects.filter(user_stats__user=user).aggregate(Sum('made_frames'))['made_frames__sum']
     if made_frames == None:
         made_frames = 0   
@@ -257,6 +260,7 @@ def get_semantics_stats(user):
                       'corr_frames': corr_frames,
                       'part_corr_frames': part_corr_frames,
                       'checked_frames': ncorr_frames+corr_frames+part_corr_frames,
+                      'related_frames': related_frames,
                       'made_frames': made_frames,
                       'efficacy': round(efficacy, 2),
                       'added_connections' : added_connections}
@@ -1369,7 +1369,7 @@ class AspectRelationsGroup(Model):
         return ','.join(str_ls)
  
 class Entry(Model):
-    name = CharField(max_length=64, db_column='nazwa') # usunieto , unique=True
+    name = CharField(max_length=64, db_column='nazwa')
     # czesc mowy
     pos = ForeignKey('POS', db_column='czesc_mowy', related_name='entries')
     # powiazane lematy
@@ -1395,23 +1395,45 @@ class Entry(Model):
             ('change_semantics', u'Może edytować semantykę.'),
             ('view_semantics', u'Może oglądać semantykę.'),
         )
-    
+
+    def related_frames(self):
+        visible = self.visible_frames()
+        actual = self.actual_frames()
+        return visible.exclude(pk__in=actual)
+
+    def visible_frames(self):
+        frames = []
+        for frame in self.all_frames():
+            for lu in frame.lexical_units.all():
+                if self.meanings.filter(pk=lu.pk).exists():
+                    frames.append(frame.pk)
+                    break
+        return get_model('semantics', 'SemanticFrame').objects.filter(pk__in=frames)
+
+    def all_frames(self):
+        frames = self.actual_frames()
+        for entry in self.rel_entries.all():
+            new_frames = entry.actual_frames()
+            frames |= new_frames
+        return get_model('semantics', 'SemanticFrame').objects.filter(pk__in=frames)
+
     def actual_frames(self):
-        # frame_ids = []
-        # lexical_units = self.meanings.order_by('sense')
-        # for lexical_unit in lexical_units:
-        #     frame_ids.extend([f.id for f in lexical_unit.actual_frames()])
-        # return get_model('semantics', 'SemanticFrame').objects.filter(id__in=list(set(frame_ids)))
         return self.semantic_frames.filter(next__isnull=True, removed=False)
+
+    def actual_schemata(self):
+        return self.lemmas.get(old=False).frames.all()
+
+    def filter_local(self, frames):
+        return frames.filter(pk__in=self.semantic_frames.all())
+
+    def filter_related(self, frames):
+        return frames.exclude(pk__in=self.semantic_frames.all())
  
     def matching_connections(self, schema, position, phrase_type):
  
         matching_connections = []
  
-        frames = self.actual_frames()
-        for entry in self.rel_entries.all():
-            new_frames = entry.actual_frames()
-            frames |= new_frames
+        frames = self.visible_frames()
  
         for frame in frames:
             for compl in frame.complements.all():
@@ -9,12 +9,8 @@ from wordnet.models import LexicalUnit
 def get_semantic_operations(lemma, schemata_conversions):
     connections = []
     operations = []
-    # frames = lemma.entry_obj.actual_frames()
  
-    frames = lemma.entry_obj.actual_frames()
-    for entry in lemma.entry_obj.rel_entries.all():
-        new_frames = entry.actual_frames()
-        frames |= new_frames
+    frames = lemma.entry_obj.visible_frames()
  
     for conv in schemata_conversions:
         schema_operations = get_reconnect_operations_and_extend_connections(frames,
@@ -3567,13 +3567,15 @@ function restore_lemma() {
 	        HideProgressAnimation();
 	        error_alert('Nie zaznaczono hasła w zakładce "Schematy" lub "Podglądzie hasła".');
 	        return false;
-	      }
-	      else if (result == 'can not edit') {
+	      } else if (result == 'can not edit') {
 		    HideProgressAnimation();
 		    error_alert('Brak uprawnień do edycji hasła.');
 		    return false;
-		  }
-	      else {
+		  } else if (result == 'shared frames') {
+		    HideProgressAnimation();
+		    error_alert('Nie można anulować: Hasła współdzielą ramy semantyczne.');
+		    return false;
+		  } else {
 	        HideProgressAnimation();
 	        return true;
 	      }
@@ -123,12 +123,13 @@
 <table class='PaymentsTable'>
   <tr> 
     <td class='EmptyCell' colspan=1></td> 
-	<td class='ColumnHeader' colspan=7>Semantycy:</td>
+	<td class='ColumnHeader' colspan=8>Semantycy:</td>
 	<td class='ColumnHeader' colspan=3>Supersemantycy:</td>
   </tr>
   <tr> 
 	<td class='ColumnHeader'>Kwota za wykonaną pracę:</td>
 	<td class='ColumnHeader'>Bonus:</td>
+	<td class='ColumnHeader'>Współdzielone ramy:</td>
 	<td class='ColumnHeader'>Wykonane ramy:</td>
 	<td class='ColumnHeader'>Poprawnie wykonane ramy:</td>
 	<td class='ColumnHeader'>Częściowo poprawnie wykonane ramy:</td>
@@ -142,6 +143,7 @@
   <tr> 
 	<td>{{semantics_work_stats.earned_cash}} zł</td>
 	<td>{{semantics_work_stats.bonus_cash}} zł</td>
+	<td>{{semantics_work_stats.related_frames}}</td>
 	<td>{{semantics_work_stats.made_frames}}</td>
 	<td>{{semantics_work_stats.prop_frames}}</td>
 	<td>{{semantics_work_stats.part_prop_frames}}</td>
@@ -16,7 +16,7 @@ class Command(BaseCommand):
 def find_hanging_connections():
     lemmas = Lemma.objects.filter(old=False).order_by('entry_obj__name')
     for lemma in lemmas:
-        frames = lemma.entry_obj.actual_frames()
+        frames = lemma.entry_obj.visible_frames()
         for frame in frames:
             for compl in frame.complements.all():
                 for real in compl.realizations.all():
@@ -8,15 +8,15 @@ from semantics.utils import get_structural_matching_frame
  
 def validate_frames(lemma_id):
     lemma = Lemma.objects.get(id=lemma_id)
-    actual_frames = lemma.entry_obj.actual_frames()
+    visible_frames = lemma.entry_obj.visible_frames()
     error_msg = u''
-    for frame in actual_frames.all():
-        error_msg = frame_valid(lemma, frame, actual_frames)
+    for frame in visible_frames.all():
+        error_msg = frame_valid(lemma, frame, visible_frames)
         if error_msg:
             break
     return error_msg
  
-def frame_valid(lemma, frame, actual_frames):
+def frame_valid(lemma, frame, frames):
     error_msg = ''
     complements = frame.complements.all()
     if not arguments_exists(complements):
@@ -33,7 +33,7 @@ def frame_valid(lemma, frame, actual_frames):
         error_msg = u'Semantyka: Rama semantyczna %d zawiera argumenty bez zdefiniowanych preferencji selekcyjnych.' % frame.id
     elif not examples_added(frame):
         error_msg = u'Semantyka: Rama semantyczna %d nie ma dopiętych przykładów.' % frame.id
-    elif duplicates_exists(frame, actual_frames):
+    elif duplicates_exists(frame, frames):
         error_msg = u'Semantyka: Rama semantyczna %d posiada duplikaty.' % frame.id
     elif not schemas_reflex_agreed(lemma, frame):
         error_msg = u'Semantyka: Rama semantyczna %d ma dopięte elementy o niezgodnej zwrotności.' % frame.id
@@ -107,8 +107,12 @@ def examples_added(frame):
             return True
     return False
  
-def duplicates_exists(frame, actual_frames):
-    frames_to_check = actual_frames.exclude(id=frame.id)
+def duplicates_exists(frame, frames):
+    # frazeologicznych ram nie sprawdzamy
+    if frame.complements.filter(roles__role='Lemma').exists():
+        return False
+
+    frames_to_check = frames.exclude(id=frame.id)
     if get_structural_matching_frame(frames_to_check, frame):
         return True
     return False
@@ -236,7 +240,7 @@ def validate_schemas(lemma_id):
     return error_msg
  
 def all_schemas_used(lemma):
-    frames = lemma.entry_obj.actual_frames()
+    frames = lemma.entry_obj.visible_frames()
     schemas = lemma.frames
     for schema in schemas.all():
         if not schema_is_bad(lemma, schema) and not schema_used(schema, frames):
@@ -92,10 +92,7 @@ def create_frames_context(lemma_id, user):
     frames_dict = {}
     frame_units = {}
  
-    frames = lemma.entry_obj.actual_frames()
-    for entry in connected:
-        new_frames = entry.actual_frames()
-        frames |= new_frames
+    frames = lemma.entry_obj.all_frames()
  
     for frame in frames:
         alternations[frame.id] = {}