diff --git a/accounts/models.py b/accounts/models.py
index ff9dfa7..cb21b54 100644
--- a/accounts/models.py
+++ b/accounts/models.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)
diff --git a/dictionary/ajax_lemma_status.py b/dictionary/ajax_lemma_status.py
index 2a85574..1b3530a 100644
--- a/dictionary/ajax_lemma_status.py
+++ b/dictionary/ajax_lemma_status.py
@@ -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):
diff --git a/dictionary/ajax_lemma_view.py b/dictionary/ajax_lemma_view.py
index 2663687..b472270 100644
--- a/dictionary/ajax_lemma_view.py
+++ b/dictionary/ajax_lemma_view.py
@@ -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)
diff --git a/dictionary/ajax_user_stats.py b/dictionary/ajax_user_stats.py
index 6028f66..aa9a345 100644
--- a/dictionary/ajax_user_stats.py
+++ b/dictionary/ajax_user_stats.py
@@ -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}
diff --git a/dictionary/models.py b/dictionary/models.py
index 1ea63bf..59be341 100644
--- a/dictionary/models.py
+++ b/dictionary/models.py
@@ -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():
diff --git a/dictionary/saving.py b/dictionary/saving.py
index b86715d..baae225 100644
--- a/dictionary/saving.py
+++ b/dictionary/saving.py
@@ -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,
diff --git a/dictionary/static/js/lemma-view.js b/dictionary/static/js/lemma-view.js
index 142e105..ca5e87c 100644
--- a/dictionary/static/js/lemma-view.js
+++ b/dictionary/static/js/lemma-view.js
@@ -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;
}
diff --git a/dictionary/templates/sel_user_stats.html b/dictionary/templates/sel_user_stats.html
index 0e80e21..927b884 100644
--- a/dictionary/templates/sel_user_stats.html
+++ b/dictionary/templates/sel_user_stats.html
@@ -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>
diff --git a/semantics/management/commands/find_hanging_connections.py b/semantics/management/commands/find_hanging_connections.py
index 25a8b02..a645a58 100644
--- a/semantics/management/commands/find_hanging_connections.py
+++ b/semantics/management/commands/find_hanging_connections.py
@@ -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():
diff --git a/semantics/validation.py b/semantics/validation.py
index 641565e..1430de9 100644
--- a/semantics/validation.py
+++ b/semantics/validation.py
@@ -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):
diff --git a/semantics/views.py b/semantics/views.py
index 0b913f3..ca22d97 100644
--- a/semantics/views.py
+++ b/semantics/views.py
@@ -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] = {}