← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to ivle/database.py

  • Committer: William Grant
  • Date: 2009-05-31 01:30:23 UTC
  • mto: (1281.1.8 aufsless)
  • mto: This revision was merged to the branch mainline in revision 1300.
  • Revision ID: grantw@unimelb.edu.au-20090531013023-8pril9e3e1tol9b2
Don't hide exceptions encountered in ivle-remakeuser.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/database.py
17
17
 
18
18
# Author: Matt Giuca, Will Grant
19
19
 
20
 
"""
21
 
Database Classes and Utilities for Storm ORM
 
20
"""Database utilities and content classes.
22
21
 
23
22
This module provides all of the classes which map to database tables.
24
23
It also provides miscellaneous utility functions for database interaction.
29
28
 
30
29
from storm.locals import create_database, Store, Int, Unicode, DateTime, \
31
30
                         Reference, ReferenceSet, Bool, Storm, Desc
 
31
from storm.expr import Select, Max
32
32
from storm.exceptions import NotOneError, IntegrityError
33
33
 
34
34
from ivle.worksheet.rst import rst
80
80
# USERS #
81
81
 
82
82
class User(Storm):
83
 
    """
84
 
    Represents an IVLE user.
85
 
    """
 
83
    """An IVLE user account."""
86
84
    __storm_table__ = "login"
87
85
 
88
86
    id = Int(primary=True, name="loginid")
119
117
 
120
118
    @property
121
119
    def display_name(self):
 
120
        """Returns the "nice name" of the user or group."""
122
121
        return self.fullname
123
122
 
124
123
    @property
 
124
    def short_name(self):
 
125
        """Returns the database "identifier" name of the user or group."""
 
126
        return self.login
 
127
 
 
128
    @property
125
129
    def password_expired(self):
126
130
        fieldval = self.pass_exp
127
131
        return fieldval is not None and datetime.datetime.now() > fieldval
164
168
 
165
169
    # TODO: Invitations should be listed too?
166
170
    def get_groups(self, offering=None):
 
171
        """Get groups of which this user is a member.
 
172
 
 
173
        @param offering: An optional offering to restrict the search to.
 
174
        """
167
175
        preds = [
168
176
            ProjectGroupMembership.user_id == self.id,
169
177
            ProjectGroup.id == ProjectGroupMembership.project_group_id,
190
198
        return self._get_enrolments(False) 
191
199
 
192
200
    def get_projects(self, offering=None, active_only=True):
193
 
        '''Return Projects that the user can submit.
 
201
        """Find projects that the user can submit.
194
202
 
195
203
        This will include projects for offerings in which the user is
196
204
        enrolled, as long as the project is not in a project set which has
197
205
        groups (ie. if maximum number of group members is 0).
198
206
 
199
 
        Unless active_only is False, only projects for active offerings will
200
 
        be returned.
201
 
 
202
 
        If an offering is specified, returned projects will be limited to
203
 
        those for that offering.
204
 
        '''
 
207
        @param active_only: Whether to only search active offerings.
 
208
        @param offering: An optional offering to restrict the search to.
 
209
        """
205
210
        return Store.of(self).find(Project,
206
211
            Project.project_set_id == ProjectSet.id,
207
212
            ProjectSet.max_students_per_group == None,
214
219
 
215
220
    @staticmethod
216
221
    def hash_password(password):
 
222
        """Hash a password with MD5."""
217
223
        return hashlib.md5(password).hexdigest()
218
224
 
219
225
    @classmethod
220
226
    def get_by_login(cls, store, login):
221
 
        """
222
 
        Get the User from the db associated with a given store and
223
 
        login.
224
 
        """
 
227
        """Find a user in a store by login name."""
225
228
        return store.find(cls, cls.login == unicode(login)).one()
226
229
 
227
230
    def get_permissions(self, user):
 
231
        """Determine privileges held by a user over this object.
 
232
 
 
233
        If the user requesting privileges is this user or an admin,
 
234
        they may do everything. Otherwise they may do nothing.
 
235
        """
228
236
        if user and user.admin or user is self:
229
237
            return set(['view', 'edit', 'submit_project'])
230
238
        else:
233
241
# SUBJECTS AND ENROLMENTS #
234
242
 
235
243
class Subject(Storm):
 
244
    """A subject (or course) which is run in some semesters."""
 
245
 
236
246
    __storm_table__ = "subject"
237
247
 
238
248
    id = Int(primary=True, name="subjectid")
249
259
        return "<%s '%s'>" % (type(self).__name__, self.short_name)
250
260
 
251
261
    def get_permissions(self, user):
 
262
        """Determine privileges held by a user over this object.
 
263
 
 
264
        If the user requesting privileges is an admin, they may edit.
 
265
        Otherwise they may only read.
 
266
        """
252
267
        perms = set()
253
268
        if user is not None:
254
269
            perms.add('view')
257
272
        return perms
258
273
 
259
274
    def active_offerings(self):
260
 
        """Return a sequence of currently active offerings for this subject
 
275
        """Find active offerings for this subject.
 
276
 
 
277
        Return a sequence of currently active offerings for this subject
261
278
        (offerings whose semester.state is "current"). There should be 0 or 1
262
279
        elements in this sequence, but it's possible there are more.
263
280
        """
265
282
                                   Semester.state == u'current')
266
283
 
267
284
    def offering_for_semester(self, year, semester):
268
 
        """Get the offering for the given year/semester, or None."""
 
285
        """Get the offering for the given year/semester, or None.
 
286
 
 
287
        @param year: A string representation of the year.
 
288
        @param semester: A string representation of the semester.
 
289
        """
269
290
        return self.offerings.find(Offering.semester_id == Semester.id,
270
291
                               Semester.year == unicode(year),
271
292
                               Semester.semester == unicode(semester)).one()
272
293
 
273
294
class Semester(Storm):
 
295
    """A semester in which subjects can be run."""
 
296
 
274
297
    __storm_table__ = "semester"
275
298
 
276
299
    id = Int(primary=True, name="semesterid")
290
313
        return "<%s %s/%s>" % (type(self).__name__, self.year, self.semester)
291
314
 
292
315
class Offering(Storm):
 
316
    """An offering of a subject in a particular semester."""
 
317
 
293
318
    __storm_table__ = "offering"
294
319
 
295
320
    id = Int(primary=True, name="offeringid")
318
343
                                  self.semester)
319
344
 
320
345
    def enrol(self, user, role=u'student'):
321
 
        '''Enrol a user in this offering.'''
 
346
        """Enrol a user in this offering.
 
347
 
 
348
        Enrolments handle both the staff and student cases. The role controls
 
349
        the privileges granted by this enrolment.
 
350
        """
322
351
        enrolment = Store.of(self).find(Enrolment,
323
352
                               Enrolment.user_id == user.id,
324
353
                               Enrolment.offering_id == self.id).one()
349
378
        return perms
350
379
 
351
380
    def get_enrolment(self, user):
 
381
        """Find the user's enrolment in this offering."""
352
382
        try:
353
383
            enrolment = self.enrolments.find(user=user).one()
354
384
        except NotOneError:
356
386
 
357
387
        return enrolment
358
388
 
 
389
    def get_members_by_role(self, role):
 
390
        return Store.of(self).find(User,
 
391
                Enrolment.user_id == User.id,
 
392
                Enrolment.offering_id == self.id,
 
393
                Enrolment.role == role
 
394
                )
 
395
 
 
396
    @property
 
397
    def students(self):
 
398
        return self.get_members_by_role(u'student')
 
399
 
359
400
class Enrolment(Storm):
 
401
    """An enrolment of a user in an offering.
 
402
 
 
403
    This represents the roles of both staff and students.
 
404
    """
 
405
 
360
406
    __storm_table__ = "enrolment"
361
407
    __storm_primary__ = "user_id", "offering_id"
362
408
 
385
431
# PROJECTS #
386
432
 
387
433
class ProjectSet(Storm):
 
434
    """A set of projects that share common groups.
 
435
 
 
436
    Each student project group is attached to a project set. The group is
 
437
    valid for all projects in the group's set.
 
438
    """
 
439
 
388
440
    __storm_table__ = "project_set"
389
441
 
390
442
    id = Int(name="projectsetid", primary=True)
401
453
        return "<%s %d in %r>" % (type(self).__name__, self.id,
402
454
                                  self.offering)
403
455
 
 
456
    def get_permissions(self, user):
 
457
        return self.offering.get_permissions(user)
 
458
 
 
459
    @property
 
460
    def assigned(self):
 
461
        """Get the entities (groups or users) assigned to submit this project.
 
462
 
 
463
        This will be a Storm ResultSet.
 
464
        """
 
465
        #If its a solo project, return everyone in offering
 
466
        if self.max_students_per_group is None:
 
467
            return self.offering.students
 
468
        else:
 
469
            return self.project_groups
 
470
 
404
471
class Project(Storm):
 
472
    """A student project for which submissions can be made."""
 
473
 
405
474
    __storm_table__ = "project"
406
475
 
407
476
    id = Int(name="projectid", primary=True)
432
501
    def submit(self, principal, path, revision, who):
433
502
        """Submit a Subversion path and revision to a project.
434
503
 
435
 
        'principal' is the owner of the Subversion repository, and the
436
 
        entity on behalf of whom the submission is being made. 'path' is
437
 
        a path within that repository, and 'revision' specifies which
438
 
        revision of that path. 'who' is the person making the submission.
 
504
        @param principal: The owner of the Subversion repository, and the
 
505
                          entity on behalf of whom the submission is being made
 
506
        @param path: A path within that repository to submit.
 
507
        @param revision: The revision of that path to submit.
 
508
        @param who: The user who is actually making the submission.
439
509
        """
440
510
 
441
511
        if not self.can_submit(principal):
451
521
 
452
522
        return ps
453
523
 
 
524
    def get_permissions(self, user):
 
525
        return self.project_set.offering.get_permissions(user)
 
526
 
 
527
    @property
 
528
    def latest_submissions(self):
 
529
        """Return the latest submission for each Assessed."""
 
530
        return Store.of(self).find(ProjectSubmission,
 
531
            Assessed.project_id == self.id,
 
532
            ProjectSubmission.assessed_id == Assessed.id,
 
533
            ProjectSubmission.date_submitted == Select(
 
534
                    Max(ProjectSubmission.date_submitted),
 
535
                    ProjectSubmission.assessed_id == Assessed.id,
 
536
                    tables=ProjectSubmission
 
537
            )
 
538
        )
 
539
 
454
540
 
455
541
class ProjectGroup(Storm):
 
542
    """A group of students working together on a project."""
 
543
 
456
544
    __storm_table__ = "project_group"
457
545
 
458
546
    id = Int(name="groupid", primary=True)
477
565
 
478
566
    @property
479
567
    def display_name(self):
480
 
        return '%s (%s)' % (self.nick, self.name)
 
568
        """Returns the "nice name" of the user or group."""
 
569
        return self.nick
 
570
 
 
571
    @property
 
572
    def short_name(self):
 
573
        """Returns the database "identifier" name of the user or group."""
 
574
        return self.name
481
575
 
482
576
    def get_projects(self, offering=None, active_only=True):
483
 
        '''Return Projects that the group can submit.
 
577
        '''Find projects that the group can submit.
484
578
 
485
579
        This will include projects in the project set which owns this group,
486
580
        unless the project set disallows groups (in which case none will be
487
581
        returned).
488
582
 
489
 
        Unless active_only is False, projects will only be returned if the
490
 
        group's offering is active.
491
 
 
492
 
        If an offering is specified, projects will only be returned if it
493
 
        matches the group's.
 
583
        @param active_only: Whether to only search active offerings.
 
584
        @param offering: An optional offering to restrict the search to.
494
585
        '''
495
586
        return Store.of(self).find(Project,
496
587
            Project.project_set_id == ProjectSet.id,
509
600
            return set()
510
601
 
511
602
class ProjectGroupMembership(Storm):
 
603
    """A student's membership in a project group."""
 
604
 
512
605
    __storm_table__ = "group_member"
513
606
    __storm_primary__ = "user_id", "project_group_id"
514
607
 
524
617
                                  self.project_group)
525
618
 
526
619
class Assessed(Storm):
 
620
    """A composite of a user or group combined with a project.
 
621
 
 
622
    Each project submission and extension refers to an Assessed. It is the
 
623
    sole specifier of the repository and project.
 
624
    """
 
625
 
527
626
    __storm_table__ = "assessed"
528
627
 
529
628
    id = Int(name="assessedid", primary=True)
542
641
        return "<%s %r in %r>" % (type(self).__name__,
543
642
            self.user or self.project_group, self.project)
544
643
 
 
644
    @property
 
645
    def is_group(self):
 
646
        """True if the Assessed is a group, False if it is a user."""
 
647
        return self.project_group is not None
 
648
 
 
649
    @property
 
650
    def principal(self):
 
651
        return self.project_group or self.user
 
652
 
545
653
    @classmethod
546
654
    def get(cls, store, principal, project):
 
655
        """Find or create an Assessed for the given user or group and project.
 
656
 
 
657
        @param principal: The user or group.
 
658
        @param project: The project.
 
659
        """
547
660
        t = type(principal)
548
661
        if t not in (User, ProjectGroup):
549
662
            raise AssertionError('principal must be User or ProjectGroup')
566
679
 
567
680
 
568
681
class ProjectExtension(Storm):
 
682
    """An extension granted to a user or group on a particular project.
 
683
 
 
684
    The user or group and project are specified by the Assessed.
 
685
    """
 
686
 
569
687
    __storm_table__ = "project_extension"
570
688
 
571
689
    id = Int(name="extensionid", primary=True)
577
695
    notes = Unicode()
578
696
 
579
697
class ProjectSubmission(Storm):
 
698
    """A submission from a user or group repository to a particular project.
 
699
 
 
700
    The content of a submission is a single path and revision inside a
 
701
    repository. The repository is that owned by the submission's user and
 
702
    group, while the path and revision are explicit.
 
703
 
 
704
    The user or group and project are specified by the Assessed.
 
705
    """
 
706
 
580
707
    __storm_table__ = "project_submission"
581
708
 
582
709
    id = Int(name="submissionid", primary=True)
592
719
# WORKSHEETS AND EXERCISES #
593
720
 
594
721
class Exercise(Storm):
 
722
    """An exercise for students to complete in a worksheet.
 
723
 
 
724
    An exercise may be present in any number of worksheets.
 
725
    """
 
726
 
595
727
    __storm_table__ = "exercise"
596
728
    id = Unicode(primary=True, name="identifier")
597
729
    name = Unicode()
609
741
        'WorksheetExercise.worksheet_id',
610
742
        'Worksheet.id'
611
743
    )
612
 
    
 
744
 
613
745
    test_suites = ReferenceSet(id, 
614
746
        'TestSuite.exercise_id',
615
747
        order_by='seq_no')
626
758
            if user.admin:
627
759
                perms.add('edit')
628
760
                perms.add('view')
629
 
            elif 'lecturer' in set((e.role for e in user.active_enrolments)):
630
 
                perms.add('edit')
631
 
                perms.add('view')
632
 
            
 
761
            elif u'lecturer' in set((e.role for e in user.active_enrolments)):
 
762
                perms.add('edit')
 
763
                perms.add('view')
 
764
            elif u'tutor' in set((e.role for e in user.active_enrolments)):
 
765
                perms.add('edit')
 
766
                perms.add('view')
 
767
 
633
768
        return perms
634
 
    
 
769
 
635
770
    def get_description(self):
 
771
        """Return the description interpreted as reStructuredText."""
636
772
        return rst(self.description)
637
773
 
638
774
    def delete(self):
644
780
        Store.of(self).remove(self)
645
781
 
646
782
class Worksheet(Storm):
 
783
    """A worksheet with exercises for students to complete.
 
784
 
 
785
    Worksheets are owned by offerings.
 
786
    """
 
787
 
647
788
    __storm_table__ = "worksheet"
648
789
 
649
790
    id = Int(primary=True, name="worksheetid")
675
816
        return "<%s %s>" % (type(self).__name__, self.name)
676
817
 
677
818
    def remove_all_exercises(self):
678
 
        """
679
 
        Remove all exercises from this worksheet.
 
819
        """Remove all exercises from this worksheet.
 
820
 
680
821
        This does not delete the exercises themselves. It just removes them
681
822
        from the worksheet.
682
823
        """
686
827
                raise IntegrityError()
687
828
        store.find(WorksheetExercise,
688
829
            WorksheetExercise.worksheet == self).remove()
689
 
            
 
830
 
690
831
    def get_permissions(self, user):
691
832
        return self.offering.get_permissions(user)
692
 
    
 
833
 
693
834
    def get_xml(self):
694
835
        """Returns the xml of this worksheet, converts from rst if required."""
695
836
        if self.format == u'rst':
697
838
            return ws_xml
698
839
        else:
699
840
            return self.data
700
 
    
 
841
 
701
842
    def delete(self):
702
843
        """Deletes the worksheet, provided it has no attempts on any exercises.
703
 
        
 
844
 
704
845
        Returns True if delete succeeded, or False if this worksheet has
705
846
        attempts attached."""
706
847
        for ws_ex in self.all_worksheet_exercises:
707
848
            if ws_ex.saves.count() > 0 or ws_ex.attempts.count() > 0:
708
849
                raise IntegrityError()
709
 
        
 
850
 
710
851
        self.remove_all_exercises()
711
852
        Store.of(self).remove(self)
712
 
        
 
853
 
713
854
class WorksheetExercise(Storm):
 
855
    """A link between a worksheet and one of its exercises.
 
856
 
 
857
    These may be marked optional, in which case the exercise does not count
 
858
    for marking purposes. The sequence number is used to order the worksheet
 
859
    ToC.
 
860
    """
 
861
 
714
862
    __storm_table__ = "worksheet_exercise"
715
 
    
 
863
 
716
864
    id = Int(primary=True, name="ws_ex_id")
717
865
 
718
866
    worksheet_id = Int(name="worksheetid")
722
870
    optional = Bool()
723
871
    active = Bool()
724
872
    seq_no = Int()
725
 
    
 
873
 
726
874
    saves = ReferenceSet(id, "ExerciseSave.ws_ex_id")
727
875
    attempts = ReferenceSet(id, "ExerciseAttempt.ws_ex_id")
728
876
 
734
882
 
735
883
    def get_permissions(self, user):
736
884
        return self.worksheet.get_permissions(user)
737
 
    
 
885
 
738
886
 
739
887
class ExerciseSave(Storm):
740
 
    """
741
 
    Represents a potential solution to an exercise that a user has submitted
742
 
    to the server for storage.
743
 
    A basic ExerciseSave is just the current saved text for this exercise for
744
 
    this user (doesn't count towards their attempts).
745
 
    ExerciseSave may be extended with additional semantics (such as
746
 
    ExerciseAttempt).
747
 
    """
 
888
    """A potential exercise solution submitted by a user for storage.
 
889
 
 
890
    This is not an actual tested attempt at an exercise, it's just a save of
 
891
    the editing session.
 
892
    """
 
893
 
748
894
    __storm_table__ = "exercise_save"
749
895
    __storm_primary__ = "ws_ex_id", "user_id"
750
896
 
763
909
            self.exercise.name, self.user.login, self.date.strftime("%c"))
764
910
 
765
911
class ExerciseAttempt(ExerciseSave):
766
 
    """
767
 
    An ExerciseAttempt is a special case of an ExerciseSave. Like an
768
 
    ExerciseSave, it constitutes exercise solution data that the user has
769
 
    submitted to the server for storage.
770
 
    In addition, it contains additional information about the submission.
771
 
    complete - True if this submission was successful, rendering this exercise
772
 
        complete for this user.
773
 
    active - True if this submission is "active" (usually true). Submissions
774
 
        may be de-activated by privileged users for special reasons, and then
775
 
        they won't count (either as a penalty or success), but will still be
776
 
        stored.
777
 
    """
 
912
    """An attempt at solving an exercise.
 
913
 
 
914
    This is a special case of ExerciseSave, used when the user submits a
 
915
    candidate solution. Like an ExerciseSave, it constitutes exercise solution
 
916
    data.
 
917
 
 
918
    In addition, it contains information about the result of the submission:
 
919
 
 
920
     - complete - True if this submission was successful, rendering this
 
921
                  exercise complete for this user in this worksheet.
 
922
     - active   - True if this submission is "active" (usually true).
 
923
                  Submissions may be de-activated by privileged users for
 
924
                  special reasons, and then they won't count (either as a
 
925
                  penalty or success), but will still be stored.
 
926
    """
 
927
 
778
928
    __storm_table__ = "exercise_attempt"
779
929
    __storm_primary__ = "ws_ex_id", "user_id", "date"
780
930
 
783
933
    text = Unicode(name="attempt")
784
934
    complete = Bool()
785
935
    active = Bool()
786
 
    
 
936
 
787
937
    def get_permissions(self, user):
788
938
        return set(['view']) if user is self.user else set()
789
 
  
 
939
 
790
940
class TestSuite(Storm):
791
 
    """A Testsuite acts as a container for the test cases of an exercise."""
 
941
    """A container to group an exercise's test cases.
 
942
 
 
943
    The test suite contains some information on how to test. The function to
 
944
    test, variables to set and stdin data are stored here.
 
945
    """
 
946
 
792
947
    __storm_table__ = "test_suite"
793
948
    __storm_primary__ = "exercise_id", "suiteid"
794
 
    
 
949
 
795
950
    suiteid = Int()
796
951
    exercise_id = Unicode(name="exerciseid")
797
952
    description = Unicode()
801
956
    exercise = Reference(exercise_id, Exercise.id)
802
957
    test_cases = ReferenceSet(suiteid, 'TestCase.suiteid', order_by="seq_no")
803
958
    variables = ReferenceSet(suiteid, 'TestSuiteVar.suiteid', order_by='arg_no')
804
 
    
 
959
 
805
960
    def delete(self):
806
961
        """Delete this suite, without asking questions."""
807
962
        for vaariable in self.variables:
811
966
        Store.of(self).remove(self)
812
967
 
813
968
class TestCase(Storm):
814
 
    """A TestCase is a member of a TestSuite.
815
 
    
816
 
    It contains the data necessary to check if an exercise is correct"""
 
969
    """A container for actual tests (see TestCasePart), inside a test suite.
 
970
 
 
971
    It is the lowest level shown to students on their pass/fail status."""
 
972
 
817
973
    __storm_table__ = "test_case"
818
974
    __storm_primary__ = "testid", "suiteid"
819
 
    
 
975
 
820
976
    testid = Int()
821
977
    suiteid = Int()
822
978
    suite = Reference(suiteid, "TestSuite.suiteid")
824
980
    failmsg = Unicode()
825
981
    test_default = Unicode()
826
982
    seq_no = Int()
827
 
    
 
983
 
828
984
    parts = ReferenceSet(testid, "TestCasePart.testid")
829
 
    
 
985
 
830
986
    __init__ = _kwarg_init
831
 
    
 
987
 
832
988
    def delete(self):
833
989
        for part in self.parts:
834
990
            part.delete()
835
991
        Store.of(self).remove(self)
836
992
 
837
993
class TestSuiteVar(Storm):
838
 
    """A container for the arguments of a Test Suite"""
 
994
    """A variable used by an exercise test suite.
 
995
 
 
996
    This may represent a function argument or a normal variable.
 
997
    """
 
998
 
839
999
    __storm_table__ = "suite_variable"
840
1000
    __storm_primary__ = "varid"
841
 
    
 
1001
 
842
1002
    varid = Int()
843
1003
    suiteid = Int()
844
1004
    var_name = Unicode()
845
1005
    var_value = Unicode()
846
1006
    var_type = Unicode()
847
1007
    arg_no = Int()
848
 
    
 
1008
 
849
1009
    suite = Reference(suiteid, "TestSuite.suiteid")
850
 
    
 
1010
 
851
1011
    __init__ = _kwarg_init
852
 
    
 
1012
 
853
1013
    def delete(self):
854
1014
        Store.of(self).remove(self)
855
 
    
 
1015
 
856
1016
class TestCasePart(Storm):
857
 
    """A container for the test elements of a Test Case"""
 
1017
    """An actual piece of code to test an exercise solution."""
 
1018
 
858
1019
    __storm_table__ = "test_case_part"
859
1020
    __storm_primary__ = "partid"
860
 
    
 
1021
 
861
1022
    partid = Int()
862
1023
    testid = Int()
863
 
    
 
1024
 
864
1025
    part_type = Unicode()
865
1026
    test_type = Unicode()
866
1027
    data = Unicode()
867
1028
    filename = Unicode()
868
 
    
 
1029
 
869
1030
    test = Reference(testid, "TestCase.testid")
870
 
    
 
1031
 
871
1032
    __init__ = _kwarg_init
872
 
    
 
1033
 
873
1034
    def delete(self):
874
1035
        Store.of(self).remove(self)