示例#1
0
    def test_update_notes_is_working_properly_with_put(self):
        """testing if PUT: /api/entities/{id}/notes should raise 404
        """
        from stalker import db, Entity, Note
        test_entity = Entity(name='Test Entity')
        db.DBSession.add(test_entity)

        # Note 1
        test_note1 = Note(content='Note 1')
        db.DBSession.add(test_note1)

        # Note 2
        test_note2 = Note(content='Note 2')
        db.DBSession.add(test_note2)

        # Note 3
        test_note3 = Note(content='Note 3')
        db.DBSession.add(test_note3)

        # Note 4
        test_note4 = Note(content='Note 4')
        db.DBSession.add(test_note4)

        # Note 5
        test_note5 = Note(content='Note 5')
        db.DBSession.add(test_note5)

        test_entity.notes = [test_note1, test_note2, test_note3]
        db.DBSession.commit()

        self.test_app.put('/api/entities/%s/notes' % test_entity.id,
                          params={'note_id': [test_note4.id, test_note5.id]},
                          status=404)
示例#2
0
    def test_get_notes_view_is_working_properly(self):
        """testing if GET /api/entities/{id}/notes view is working properly
        """
        from stalker import db, Entity, Note
        test_entity = Entity(name='Test Entity')
        db.DBSession.add(test_entity)

        test_note1 = Note(description='This is a Test note 1')
        db.DBSession.add(test_note1)

        test_note2 = Note(description='This is a Test note 2')
        db.DBSession.add(test_note2)

        test_entity.notes = [test_note1, test_note2]
        db.DBSession.commit()

        response = self.test_app.get('/api/entities/%s/notes' % test_entity.id,
                                     status=200)

        self.assertEqual(
            sorted(response.json_body),
            sorted([{
                'id': test_note1.id,
                '$ref': '/api/notes/%s' % test_note1.id,
                'name': test_note1.name,
                'entity_type': test_note1.entity_type
            }, {
                'id': test_note2.id,
                '$ref': '/api/notes/%s' % test_note2.id,
                'name': test_note2.name,
                'entity_type': test_note2.entity_type
            }]))
示例#3
0
    def setUp(self):
        """setting up some proper values
        """
        # create a user
        self.test_user = User(name="Test User",
                              login="******",
                              email="*****@*****.**",
                              password="******")

        # create some test Tag objects, not necessarily needed but create them
        self.test_tag1 = Tag(name="Test Tag 1")
        self.test_tag2 = Tag(name="Test Tag 1")  # make it equal to tag1
        self.test_tag3 = Tag(name="Test Tag 3")

        self.tags = [self.test_tag1, self.test_tag2]

        # create a couple of test Note objects
        self.test_note1 = Note(name="test note1", content="test note1")
        self.test_note2 = Note(name="test note2", content="test note2")
        self.test_note3 = Note(name="test note3", content="test note3")

        self.notes = [self.test_note1, self.test_note2]

        self.kwargs = {
            "name": "Test Entity",
            "description": "This is a test entity, and this is a proper \
            description for it",
            "created_by": self.test_user,
            "updated_by": self.test_user,
            "tags": self.tags,
            "notes": self.notes,
        }

        # create a proper SimpleEntity to use it later in the tests
        self.test_entity = Entity(**self.kwargs)
示例#4
0
    def test_entity_notes_is_working_properly(self):
        """testing if get_notes is working properly
        """
        from stalker import db, Entity, Note
        test_entity = Entity(name='Test Entity')
        db.DBSession.add(test_entity)

        # Note 1
        test_note1 = Note(content='Note 1')
        db.DBSession.add(test_note1)

        # Note 2
        test_note2 = Note(content='Note 2')
        db.DBSession.add(test_note2)

        # Note 3
        test_note3 = Note(content='Note 3')
        db.DBSession.add(test_note3)

        # dummy Note 4
        test_note4 = Note(content='Note 4')
        db.DBSession.add(test_note4)

        test_entity.notes = [test_note1, test_note2, test_note3]
        db.DBSession.commit()

        from stalker_pyramid.testing import DummyRequest
        request = DummyRequest()
        request.matchdict['id'] = test_entity.id
        request.method = 'GET'

        entity_view = entity.EntityViews(request)
        response = entity_view.get_notes()

        self.assertEqual(
            sorted(response.json_body),
            sorted([
                {
                    'id': test_note1.id,
                    '$ref': '/api/notes/%s' % test_note1.id,
                    'name': test_note1.name,
                    'entity_type': 'Note'
                },
                {
                    'id': test_note2.id,
                    '$ref': '/api/notes/%s' % test_note2.id,
                    'name': test_note2.name,
                    'entity_type': 'Note'
                },
                {
                    'id': test_note3.id,
                    '$ref': '/api/notes/%s' % test_note3.id,
                    'name': test_note3.name,
                    'entity_type': 'Note'
                },
            ]))
示例#5
0
    def test_inequality_operator(self):
        """testing inequality operator
        """
        note1 = Note(**self.kwargs)
        note2 = Note(**self.kwargs)

        self.kwargs["content"] = "this is a different content"
        note3 = Note(**self.kwargs)

        assert not note1 != note2
        assert note1 != note3
示例#6
0
    def test_equality_operator(self):
        """testing equality operator
        """
        note1 = Note(**self.kwargs)
        note2 = Note(**self.kwargs)

        self.kwargs["content"] = "this is a different content"
        note3 = Note(**self.kwargs)

        self.assertTrue(note1 == note2)
        self.assertFalse(note1 == note3)
示例#7
0
    def test_update_notes_is_working_properly_with_patch(self):
        """testing if update_notes is working properly when the request method
        is PATCH
        """
        from stalker import db, Entity, Note
        test_entity = Entity(name='Test Entity')
        db.DBSession.add(test_entity)

        # Note 1
        test_note1 = Note(content='Note 1')
        db.DBSession.add(test_note1)

        # Note 2
        test_note2 = Note(content='Note 2')
        db.DBSession.add(test_note2)

        # Note 3
        test_note3 = Note(content='Note 3')
        db.DBSession.add(test_note3)

        # Note 4
        test_note4 = Note(content='Note 4')
        db.DBSession.add(test_note4)

        # Note 5
        test_note5 = Note(content='Note 5')
        db.DBSession.add(test_note5)

        test_entity.notes = [test_note1, test_note2, test_note3]
        db.DBSession.commit()

        from stalker_pyramid.testing import DummyRequest, DummyMultiDict
        request = DummyRequest()
        request.matchdict['id'] = test_entity.id
        request.method = 'PATCH'

        # add the 4th and 5th notes
        request.params = DummyMultiDict()
        request.params['note_id'] = [test_note4.id, test_note5.id]
        request.POST = request.params

        entity_view = entity.EntityViews(request)
        entity_view.update_notes()

        test_entity = Entity.query.filter(Entity.id == test_entity.id).first()
        self.assertEqual(
            sorted(test_entity.notes),
            sorted(
                [test_note1, test_note2, test_note3, test_note4, test_note5]))
示例#8
0
 def test_content_argument_is_missing(self):
     """testing if nothing is going to happen when no content argument is
     given
     """
     self.kwargs.pop("content")
     new_note = Note(**self.kwargs)
     assert isinstance(new_note, Note)
示例#9
0
 def test_content_argument_is_set_to_None(self):
     """testing if nothing is going to happen when content argument is given
     as None
     """
     self.kwargs["content"] = None
     new_note = Note(**self.kwargs)
     assert isinstance(new_note, Note)
示例#10
0
    def test_update_entity_is_working_properly(self):
        """testing if update_note is working properly
        """
        from stalker import db, Note, User
        test_user = User(name='Test User',
                         login='******',
                         email='*****@*****.**',
                         password='******')
        db.DBSession.add(test_user)

        note1 = Note(content='This is a test note')
        db.DBSession.add(note1)
        db.DBSession.commit()

        from stalker_pyramid.testing import DummyRequest, DummyMultiDict
        request = DummyRequest()
        request.matchdict['id'] = note1.id
        request.params = DummyMultiDict()
        request.params['content'] = 'this is the new content'
        request.params['updated_by_id'] = test_user.id

        note_view = note.NoteViews(request)
        note_view.update_entity()

        note1 = Note.query.first()
        self.assertEqual(note1.content, 'this is the new content')
        self.assertEqual(note1.updated_by, test_user)
示例#11
0
    def test_get_entity_is_working_properly(self):
        """testing if GET /api/notes/{id} view is working properly
        """
        from stalker import db, Note
        test_note1 = Note(content='This is a test note', created_by=self.admin)
        db.DBSession.add(test_note1)
        db.DBSession.commit()

        response = self.test_app.get('/api/notes/%s' % test_note1.id,
                                     status=200)

        import stalker
        from stalker_pyramid.views import EntityViewBase

        self.assertEqual(
            response.json_body, {
                'created_by': {
                    'id': self.admin.id,
                    '$ref': '/api/users/%s' % self.admin.id,
                    'name': self.admin.name,
                    'entity_type': self.admin.entity_type
                },
                'content':
                'This is a test note',
                'date_created':
                EntityViewBase.milliseconds_since_epoch(
                    test_note1.date_created),
                'date_updated':
                EntityViewBase.milliseconds_since_epoch(
                    test_note1.date_updated),
                'description':
                'This is a test note',
                'entity_type':
                'Note',
                'generic_text':
                '',
                'generic_data': {
                    '$ref':
                    '/api/simple_entities/%s/generic_data' % test_note1.id,
                    'length': 0
                },
                'id':
                test_note1.id,
                'name':
                test_note1.name,
                'stalker_version':
                stalker.__version__,
                'thumbnail':
                None,
                'type':
                None,
                'updated_by': {
                    'id': self.admin.id,
                    '$ref': '/api/users/%s' % self.admin.id,
                    'name': self.admin.name,
                    'entity_type': self.admin.entity_type
                }
            })
示例#12
0
    def test_get_entities_is_working_properly(self):
        """testing if get_entities is working properly
        """
        from stalker import db, Note
        note1 = Note(content='test content 1')
        note2 = Note(content='test content 2')
        note3 = Note(content='test content 3')
        note4 = Note(content='test content 4')
        db.DBSession.add_all([note1, note2, note3, note4])
        db.DBSession.commit()

        from stalker_pyramid.testing import DummyRequest
        request = DummyRequest()

        note_views = note.NoteViews(request)
        response = note_views.get_entities()

        self.assertEqual(
            sorted(response.json_body),
            sorted([
                {
                    'id': note1.id,
                    '$ref': '/api/notes/%s' % note1.id,
                    'name': note1.name,
                    'entity_type': note1.entity_type
                },
                {
                    'id': note2.id,
                    '$ref': '/api/notes/%s' % note2.id,
                    'name': note2.name,
                    'entity_type': note2.entity_type
                },
                {
                    'id': note3.id,
                    '$ref': '/api/notes/%s' % note3.id,
                    'name': note3.name,
                    'entity_type': note3.entity_type
                },
                {
                    'id': note4.id,
                    '$ref': '/api/notes/%s' % note4.id,
                    'name': note4.name,
                    'entity_type': note4.entity_type
                },
            ]))
示例#13
0
    def test_comments_attribute_is_synonym_for_notes_attribute(self):
        """testing if the comments attribute is the synonym for the notes
        attribute, so setting one will also set the other
        """
        note1 = Note(name='Test Note 1', content='Test note 1')
        note2 = Note(name='Test Note 2', content='Test note 2')

        self.test_ticket.comments.append(note1)
        self.test_ticket.comments.append(note2)

        self.assertTrue(note1 in self.test_ticket.notes)
        self.assertTrue(note2 in self.test_ticket.notes)

        self.test_ticket.notes.remove(note1)
        self.assertFalse(note1 in self.test_ticket.comments)

        self.test_ticket.notes.remove(note2)
        self.assertFalse(note2 in self.test_ticket.comments)
示例#14
0
    def setUp(self):
        """setup the test
        """
        self.kwargs = {
            "name": "Note to something",
            "description": "this is a simple note",
            "content": "this is a note content",
        }

        # create a Note object
        self.test_note = Note(**self.kwargs)
示例#15
0
    def test_get_entities_is_working_properly(self):
        """testing GET /api/notes is working properly
        """
        from stalker import db, Note
        note1 = Note(content='test content 1')
        note2 = Note(content='test content 2')
        note3 = Note(content='test content 3')
        note4 = Note(content='test content 4')
        db.DBSession.add_all([note1, note2, note3, note4])
        db.DBSession.commit()

        response = self.test_app.get('/api/notes', status=200)

        self.assertEqual(
            sorted(response.json_body),
            sorted([
                {
                    'id': note1.id,
                    '$ref': '/api/notes/%s' % note1.id,
                    'name': note1.name,
                    'entity_type': note1.entity_type
                },
                {
                    'id': note2.id,
                    '$ref': '/api/notes/%s' % note2.id,
                    'name': note2.name,
                    'entity_type': note2.entity_type
                },
                {
                    'id': note3.id,
                    '$ref': '/api/notes/%s' % note3.id,
                    'name': note3.name,
                    'entity_type': note3.entity_type
                },
                {
                    'id': note4.id,
                    '$ref': '/api/notes/%s' % note4.id,
                    'name': note4.name,
                    'entity_type': note4.entity_type
                },
            ]))
示例#16
0
    def test_get_notes_is_working_properly(self):
        """testing get_notes() is working properly
        """
        # create a test entity with notes
        from stalker import db, Entity, Note
        # test note 1
        test_note1 = Note(content='Test note 1')
        db.DBSession.add(test_note1)

        # test note 2
        test_note2 = Note(content='Test note 2')
        db.DBSession.add(test_note2)

        # test note 3
        test_note3 = Note(content='Test note 3')
        db.DBSession.add(test_note3)

        # some other note
        test_note4 = Note(content='Test note 4')
        db.DBSession.add(test_note4)

        test_entity = Entity(name='Test Entity',
                             notes=[test_note1, test_note2, test_note3])
        db.DBSession.add(test_entity)
        db.DBSession.commit()

        from stalker_pyramid.testing import DummyRequest
        dummy_request = DummyRequest()
        dummy_request.matchdict['id'] = test_entity.id
        entity_view = entity.EntityViews(dummy_request)

        response = entity_view.get_notes()

        self.assertEqual(
            sorted(response.json_body),
            sorted([{
                'id': n.id,
                '$ref': '/api/notes/%s' % n.id,
                'name': n.name,
                'entity_type': n.entity_type
            } for n in [test_note1, test_note2, test_note3]]))
示例#17
0
    def test_content_argument_is_set_to_something_other_than_a_string(self):
        """testing if a TypeError will be raised when trying to set the content
        argument to something other than a string
        """
        test_value = 1.24

        self.kwargs["content"] = test_value
        with pytest.raises(TypeError) as cm:
            Note(**self.kwargs)

        assert str(cm.value) == \
            'Note.description should be a string, not float'
示例#18
0
    def test_delete_entity_is_working_properly(self):
        """testing if DELETE /api/notes/{id} view is working properly
        """
        from stalker import db, Note
        test_note = Note(content='This is a test note')
        db.DBSession.add(test_note)
        db.DBSession.commit()

        self.test_app.delete('/api/notes/%s' % test_note.id, status=200)

        test_note_db = Note.query.filter(Note.name == test_note.name).first()
        self.assertIsNone(test_note_db)
示例#19
0
    def test_update_notes_is_working_properly_with_patch(self):
        """testing if PATCH /api/entities/{id}/notes view is working properly
        """
        from stalker import db, Entity, Note
        test_entity = Entity(name='Test Entity')
        db.DBSession.add(test_entity)

        # Note 1
        test_note1 = Note(content='Note 1')
        db.DBSession.add(test_note1)

        # Note 2
        test_note2 = Note(content='Note 2')
        db.DBSession.add(test_note2)

        # Note 3
        test_note3 = Note(content='Note 3')
        db.DBSession.add(test_note3)

        # Note 4
        test_note4 = Note(content='Note 4')
        db.DBSession.add(test_note4)

        # Note 5
        test_note5 = Note(content='Note 5')
        db.DBSession.add(test_note5)

        test_entity.notes = [test_note1, test_note2, test_note3]
        db.DBSession.commit()

        self.test_app.patch('/api/entities/%s/notes' % test_entity.id,
                            params={'note_id': [test_note4.id, test_note5.id]},
                            status=200)

        test_entity = Entity.query.filter(Entity.id == test_entity.id).first()
        self.assertEqual(
            sorted(test_entity.notes),
            sorted(
                [test_note1, test_note2, test_note3, test_note4, test_note5]))
示例#20
0
    def test_update_entity_is_working_properly_with_post(self):
        """testing if POST /api/note/{id} is working properly
        """
        from stalker import db, Note
        note1 = Note(content='This is a test note')
        db.DBSession.add(note1)
        db.DBSession.commit()

        self.admin_login()
        self.test_app.post('/api/notes/%s' % note1.id,
                           params={'content': 'this is the new content'},
                           status=200)

        note1 = Note.query.first()
        self.assertEqual(note1.content, 'this is the new content')
示例#21
0
    def test_delete_entity_is_working_properly(self):
        """testing if the delete_entity method is working properly
        """
        from stalker import db, Note
        test_note = Note(content='This is a test note')
        db.DBSession.add(test_note)
        db.DBSession.commit()

        from stalker_pyramid.testing import DummyRequest
        request = DummyRequest()
        request.matchdict['id'] = test_note.id

        note_view = note.NoteViews(request)
        note_view.delete_entity()

        test_note_db = Note.query.filter(Note.name == test_note.name).first()
        self.assertIsNone(test_note_db)
示例#22
0
    def accept(self):
        """overridden accept method
        """
        # get the info
        task = self.tasks_combo_box.currentTask()
        resource = self.get_current_resource()

        # war the user if the resource is not the logged_in_user
        if resource != self.logged_in_user:
            msg_box = QtWidgets.QMessageBox(self)
            msg_box.setWindowTitle(
                'Entering TimeLog On Behalf of Somebody Else'
            )
            msg_box.setText(
                "You're entering a TimeLog on behalf of somebody else???"
            )
            accept_button = msg_box.addButton(
                'Accept the responsibility',
                QtWidgets.QMessageBox.AcceptRole
            )
            cancel_button = msg_box.addButton(
                'Cancel',
                QtWidgets.QMessageBox.RejectRole
            )
            msg_box.setDefaultButton(cancel_button)
            msg_box.exec_()
            clicked_button = msg_box.clickedButton()
            msg_box.deleteLater()
            if clicked_button == cancel_button:
                return

        description = self.description_plain_text_edit.toPlainText()
        revision_cause_text = \
            self.revision_type_combo_box.currentText().replace(' ', '_')

        is_complete = self.set_as_complete_radio_button.isChecked()
        submit_to_final_review = \
            self.submit_for_final_review_radio_button.isChecked()

        # get the revision Types
        from stalker import Type
        revision_type = Type.query\
            .filter(Type.target_entity_type == 'Note')\
            .filter(Type.name == revision_cause_text)\
            .first()

        date = self.calendar_widget.selectedDate()
        start = self.start_time_edit.time()
        end = self.end_time_edit.time()

        # construct proper datetime.DateTime instances
        import datetime
        start_date = datetime.datetime(
            date.year(), date.month(), date.day(),
            start.hour(), start.minute()
        )
        end_date = datetime.datetime(
            date.year(), date.month(), date.day(),
            end.hour(), end.minute()
        )

        today_midnight = datetime.datetime.now().replace(
            hour=23, minute=59, second=59, microsecond=999
        )

        # raise an error if the user is trying to enter a TimeLog to the future
        if start_date > today_midnight or end_date > today_midnight:
            QtWidgets.QMessageBox.critical(
                self,
                'Error',
                'Gelecege TimeLog giremezsiniz!!!',
            )
            return

        # convert them to utc
        from anima.utils import local_to_utc
        utc_start_date = local_to_utc(start_date)
        utc_end_date = local_to_utc(end_date)

        # create a TimeLog
        # print('Task          : %s' % task.name)
        # print('Resource      : %s' % resource.name)
        # print('utc_start_date: %s' % utc_start_date)
        # print('utc_end_date  : %s' % utc_end_date)

        # now if we are not using extra time just create the TimeLog
        from stalker import TimeLog
        from stalker.db.session import DBSession
        from stalker.exceptions import (OverBookedError,
                                        DependencyViolationError)
        utc_now = local_to_utc(datetime.datetime.now())

        # TODO: Remove this in a later version
        import stalker
        from distutils.version import LooseVersion
        if LooseVersion(stalker.__version__) >= LooseVersion('0.2.18'):
            # inject timezone info
            import pytz
            utc_start_date = utc_start_date.replace(tzinfo=pytz.utc)
            utc_end_date = utc_end_date.replace(tzinfo=pytz.utc)
            utc_now = utc_now.replace(tzinfo=pytz.utc)

        from sqlalchemy.exc import IntegrityError
        if not self.timelog:
            try:
                new_time_log = TimeLog(
                    task=task,
                    resource=resource,
                    start=utc_start_date,
                    end=utc_end_date,
                    description=description,
                    date_created=utc_now
                )
            except (OverBookedError, DependencyViolationError) as e:
                # inform the user that it can not do that
                QtWidgets.QMessageBox.critical(
                    self,
                    'Error',
                    '%s' % e
                )
                DBSession.rollback()
                return

            try:
                DBSession.add(new_time_log)
                DBSession.commit()
                self.timelog_created = True
            except IntegrityError as e:
                DBSession.rollback()
                QtWidgets.QMessageBox.critical(
                    self,
                    'Error',
                    'Database Error!!!'
                    '<br>'
                    '%s' % e
                )
                return
        else:
            # just update the date values
            self.timelog.start = utc_start_date
            self.timelog.end = utc_end_date
            self.timelog.date_updated = utc_now
            DBSession.add(self.timelog)
            DBSession.commit()

        if self.no_time_left:
            # we have no time left so automatically extend the task
            from stalker import Task
            schedule_timing, schedule_unit = \
                task.least_meaningful_time_unit(
                    task.total_logged_seconds
                )

            if schedule_timing != 0:
                task.schedule_timing = schedule_timing
                task.schedule_unit = schedule_unit

            # also create a Note
            from stalker import Note
            new_note = Note(
                content='Extending timing of the task <b>%s h %s min.</b>' % (
                    self.extended_hours,
                    self.extended_minutes
                ),
                type=revision_type,
                created_by=self.logged_in_user,
                date_created=utc_now
            )
            DBSession.add(new_note)
            task.notes.append(new_note)

            try:
                DBSession.commit()
            except IntegrityError as e:
                QtWidgets.QMessageBox.critical(
                    self,
                    'Error',
                    'Database Error!!!'
                    '<br>'
                    '%s' % e
                )
                DBSession.rollback()
                return

        if is_complete:
            # set the status to complete
            from stalker import Type, Status
            status_cmpl = Status.query.filter(Status.code == 'CMPL').first()

            forced_status_type = \
                Type.query.filter(Type.name == 'Forced Status').first()

            # also create a Note
            from stalker import Note
            new_note = Note(
                content='%s has changed this task status to Completed' %
                        resource.name,
                type=forced_status_type,
                created_by=self.logged_in_user,
                date_created=utc_now
            )
            DBSession.add(new_note)
            task.notes.append(new_note)
            task.status = status_cmpl
            DBSession.commit()

        elif submit_to_final_review:
            # clip the Task timing to current time logs
            from stalker import Task
            schedule_timing, schedule_unit = \
                task.least_meaningful_time_unit(
                    task.total_logged_seconds
                )

            task.schedule_timing = schedule_timing
            task.schedule_unit = schedule_unit
            DBSession.add(task)

            try:
                DBSession.commit()
            except IntegrityError as e:
                QtWidgets.QMessageBox.critical(
                    self,
                    'Error',
                    'Database Error!!!'
                    '<br>'
                    '%s' % e
                )
                DBSession.rollback()
                return

            # request a review
            reviews = task.request_review()
            for review in reviews:
                review.created_by = review.updated_by = self.logged_in_user
                review.date_created = utc_now
                review.date_updated = utc_now
            DBSession.add_all(reviews)

            # and create a Note for the Task
            request_review_note_type = \
                Type.query\
                    .filter(Type.target_entity_type == 'Note')\
                    .filter(Type.name == 'Request Review')\
                    .first()

            from stalker import Note
            request_review_note = Note(
                type=request_review_note_type,
                created_by=self.logged_in_user,
                date_created=utc_now
            )
            DBSession.add(request_review_note)
            DBSession.add(task)
            task.notes.append(request_review_note)

            try:
                DBSession.commit()
            except IntegrityError as e:
                DBSession.rollback()
                QtWidgets.QMessageBox.critical(
                    self,
                    'Error',
                    'Database Error!!!'
                    '<br>'
                    '%s' % e
                )
                return

        # Fix statuses
        from anima import utils
        utils.fix_task_statuses(task)
        try:
            DBSession.commit()
        except IntegrityError as e:
            DBSession.rollback()
            QtWidgets.QMessageBox.critical(
                self,
                'Error',
                'Database Error!!!'
                '<br>'
                '%s' % e
            )
            return

        # if nothing bad happens close the dialog
        super(MainDialog, self).accept()
示例#23
0
 def test_content_argument_is_set_to_empty_string(self):
     """testing if nothing is going to happen when content argument is given
     as an empty string
     """
     self.kwargs["content"] = ""
     Note(**self.kwargs)
示例#24
0
    def accept(self):
        """overridden accept method
        """
        # get the info
        task = self.tasks_comboBox.currentTask()
        resource = self.get_current_resource()

        # war the user if the resource is not the logged_in_user
        if resource != self.logged_in_user:
            msg_box = QtWidgets.QMessageBox(self)
            msg_box.setWindowTitle('Baskasi Adina TimeLog Giriyorsun')
            msg_box.setText('Baskasi adina TimeLog giriyorsun???')
            accept_button = msg_box.addButton('Sorumlulugu Kabul Ediyorum',
                                              QtWidgets.QMessageBox.AcceptRole)
            cancel_button = msg_box.addButton('Cancel',
                                              QtWidgets.QMessageBox.RejectRole)
            msg_box.setDefaultButton(cancel_button)
            msg_box.exec_()
            clicked_button = msg_box.clickedButton()
            if clicked_button == cancel_button:
                return

        description = self.description_plainTextEdit.toPlainText()
        revision_cause_text = \
            self.revision_type_comboBox.currentText().replace(' ', '_')

        is_complete = self.set_as_complete_radioButton.isChecked()
        submit_to_final_review = \
            self.submit_for_final_review_radioButton.isChecked()

        # get the revision Types
        from stalker import Type
        revision_type = Type.query\
            .filter(Type.target_entity_type == 'Note')\
            .filter(Type.name == revision_cause_text)\
            .first()

        date = self.calendarWidget.selectedDate()
        start = self.start_timeEdit.time()
        end = self.end_timeEdit.time()

        # construct proper datetime.DateTime instances
        import datetime
        start_date = datetime.datetime(date.year(), date.month(), date.day(),
                                       start.hour(), start.minute())
        end_date = datetime.datetime(date.year(), date.month(), date.day(),
                                     end.hour(), end.minute())

        today_midnight = datetime.datetime.now().replace(hour=23,
                                                         minute=59,
                                                         second=59,
                                                         microsecond=999)

        # raise an error if the user is trying to enter a TimeLog to the future
        if start_date > today_midnight or end_date > today_midnight:
            QtWidgets.QMessageBox.critical(
                self,
                'Error',
                'Gelecege TimeLog giremezsiniz!!!',
            )
            return

        # convert them to utc
        from anima.utils import local_to_utc
        utc_start_date = local_to_utc(start_date)
        utc_end_date = local_to_utc(end_date)

        # create a TimeLog
        # print('Task          : %s' % task.name)
        # print('Resource      : %s' % resource.name)
        # print('utc_start_date: %s' % utc_start_date)
        # print('utc_end_date  : %s' % utc_end_date)

        # now if we are not using extra time just create the TimeLog
        from stalker import db, TimeLog
        from stalker.exceptions import OverBookedError
        utc_now = local_to_utc(datetime.datetime.now())

        if not self.timelog:
            try:
                new_time_log = TimeLog(task=task,
                                       resource=resource,
                                       start=utc_start_date,
                                       end=utc_end_date,
                                       description=description,
                                       date_created=utc_now)
            except OverBookedError:
                # inform the user that it can not do that
                QtWidgets.QMessageBox.critical(
                    self, 'Error', 'O saatte baska time log var!!!')
                return

            from sqlalchemy.exc import IntegrityError
            try:
                db.DBSession.add(new_time_log)
                db.DBSession.commit()
                self.timelog_created = True
            except IntegrityError as e:
                QtWidgets.QMessageBox.critical(
                    self, 'Error', 'Database hatasi!!!'
                    '<br>'
                    '%s' % e)
                db.DBSession.rollback()
                return
        else:
            # just update the date values
            self.timelog.start = utc_start_date
            self.timelog.end = utc_end_date
            self.timelog.date_updated = utc_now
            db.DBSession.add(self.timelog)
            db.DBSession.commit()

        if self.no_time_left:
            # we have no time left so automatically extend the task
            from stalker import Task
            schedule_timing, schedule_unit = \
                task.least_meaningful_time_unit(
                    task.total_logged_seconds
                )

            if schedule_timing != 0:
                task.schedule_timing = schedule_timing
                task.schedule_unit = schedule_unit

            # also create a Note
            from stalker import Note
            new_note = Note(
                content='Extending timing of the task <b>%s h %s min.</b>' %
                (self.extended_hours, self.extended_minutes),
                type=revision_type,
                created_by=self.logged_in_user,
                date_created=local_to_utc(datetime.datetime.now()))
            db.DBSession.add(new_note)
            task.notes.append(new_note)

            try:
                db.DBSession.commit()
            except IntegrityError as e:
                QtWidgets.QMessageBox.critical(
                    self, 'Error', 'Database hatasi!!!'
                    '<br>'
                    '%s' % e)
                db.DBSession.rollback()
                return

        if is_complete:
            # set the status to complete
            from stalker import Type, Status
            status_cmpl = Status.query.filter(Status.code == 'CMPL').first()

            forced_status_type = \
                Type.query.filter(Type.name == 'Forced Status').first()

            # also create a Note
            from stalker import Note
            new_note = Note(
                content='%s has changed this task status to Completed' %
                resource.name,
                type=forced_status_type,
                created_by=self.logged_in_user,
                date_created=local_to_utc(datetime.datetime.now()))
            db.DBSession.add(new_note)
            task.notes.append(new_note)
            task.status = status_cmpl
            db.DBSession.commit()

            task.update_parent_statuses()
            db.DBSession.commit()

        elif submit_to_final_review:
            # clip the Task timing to current time logs
            from stalker import Task
            schedule_timing, schedule_unit = \
                task.least_meaningful_time_unit(
                    task.total_logged_seconds
                )

            task.schedule_timing = schedule_timing
            task.schedule_unit = schedule_unit
            db.DBSession.add(task)

            try:
                db.DBSession.commit()
            except IntegrityError as e:
                QtWidgets.QMessageBox.critical(
                    self, 'Error', 'Database hatasi!!!'
                    '<br>'
                    '%s' % e)
                db.DBSession.rollback()
                return

            # request a review
            reviews = task.request_review()
            utc_now = local_to_utc(datetime.datetime.now())
            for review in reviews:
                review.created_by = review.updated_by = self.logged_in_user
                review.date_created = utc_now
                review.date_updated = utc_now
            db.DBSession.add_all(reviews)

            # and create a Note for the Task
            request_review_note_type = \
                Type.query\
                    .filter(Type.target_entity_type == 'Note')\
                    .filter(Type.name == 'Request Review')\
                    .first()

            from stalker import Note
            request_review_note = Note(type=request_review_note_type,
                                       created_by=self.logged_in_user,
                                       date_created=local_to_utc(
                                           datetime.datetime.now()))
            db.DBSession.add(request_review_note)
            db.DBSession.add(task)
            task.notes.append(request_review_note)

            try:
                db.DBSession.commit()
            except IntegrityError as e:
                QtWidgets.QMessageBox.critical(
                    self, 'Error', 'Database hatasi!!!'
                    '<br>'
                    '%s' % e)
                db.DBSession.rollback()
                return

        # if nothing bad happens close the dialog
        super(MainDialog, self).accept()