models.py

            corpus_element.append(text_element)
        ET.ElementTree(corpus_element).write(
            os.path.join(self.path, 'cwb', 'corpus.vrt'),
            encoding='utf-8'
        )
        self.last_edited_date = datetime.utcnow()
        self.status = CorpusStatus.SUBMITTED

    def delete(self):
        shutil.rmtree(self.path, ignore_errors=True)
        db.session.delete(self)

    def makedirs(self):
        os.mkdir(self.path)
        os.mkdir(os.path.join(self.path, 'files'))
        os.mkdir(os.path.join(self.path, 'cwb'))
        os.mkdir(os.path.join(self.path, 'cwb', 'data'))
        os.mkdir(os.path.join(self.path, 'cwb', 'registry'))

    def to_dict(self, backrefs=False, relationships=False):
        dict_corpus = {
            'id': self.hashid,
            'user_id': self.user.hashid,
            'analysis_url': self.analysis_url,
            'url': self.url,
            'creation_date': self.creation_date.isoformat() + 'Z',
            'description': self.description,
            'max_num_tokens': self.max_num_tokens,
            'num_analysis_sessions': self.num_analysis_sessions,
            'num_tokens': self.num_tokens,
            'status': self.status.name,
            'last_edited_date': self.last_edited_date.isoformat() + 'Z',
            'title': self.title
        }
        if backrefs:
            dict_corpus['user'] = self.user.to_dict(
                backrefs=True,
                relationships=False
            )
        if relationships:
            dict_corpus['files'] = {
                x.hashid: x.to_dict(backrefs=False, relationships=True)
                for x in self.files
            }
        return dict_corpus
# endregion models


##############################################################################
# event_handlers                                                             #
##############################################################################
# region event_handlers
@db.event.listens_for(Corpus, 'after_delete')
@db.event.listens_for(CorpusFile, 'after_delete')
@db.event.listens_for(Job, 'after_delete')
@db.event.listens_for(JobInput, 'after_delete')
@db.event.listens_for(JobResult, 'after_delete')
def ressource_after_delete(mapper, connection, ressource):
    jsonpatch = [{'op': 'remove', 'path': ressource.jsonpatch_path}]
    room = f'users.{ressource.user_hashid}'
    socketio.emit('users.patch', jsonpatch, room=room)
    room = f'/users/{ressource.user_hashid}'
    socketio.emit('PATCH', jsonpatch, room=room)


@db.event.listens_for(Corpus, 'after_insert')
@db.event.listens_for(CorpusFile, 'after_insert')
@db.event.listens_for(Job, 'after_insert')
@db.event.listens_for(JobInput, 'after_insert')
@db.event.listens_for(JobResult, 'after_insert')
def ressource_after_insert_handler(mapper, connection, ressource):
    value = ressource.to_dict(backrefs=False, relationships=False)
    for attr in mapper.relationships:
        value[attr.key] = {}
    jsonpatch = [
        {'op': 'add', 'path': ressource.jsonpatch_path, 'value': value}
    ]
    room = f'/users/{ressource.user_hashid}'
    socketio.emit('PATCH', jsonpatch, room=room)


@db.event.listens_for(Corpus, 'after_update')
@db.event.listens_for(CorpusFile, 'after_update')
@db.event.listens_for(Job, 'after_update')
@db.event.listens_for(JobInput, 'after_update')
@db.event.listens_for(JobResult, 'after_update')
def ressource_after_update_handler(mapper, connection, ressource):
    jsonpatch = []
    for attr in db.inspect(ressource).attrs:
        if attr.key in mapper.relationships:
            continue
        if not attr.load_history().has_changes():
            continue
        if isinstance(attr.value, datetime):
            value = attr.value.isoformat() + 'Z'
        elif isinstance(attr.value, Enum):
            value = attr.value.name
        else:
            value = attr.value
        jsonpatch.append(
            {
                'op': 'replace',
                'path': f'{ressource.jsonpatch_path}/{attr.key}',
                'value': value
            }
        )
    if jsonpatch:
        room = f'/users/{ressource.user_hashid}'
        socketio.emit('PATCH', jsonpatch, room=room)


@db.event.listens_for(Job, 'after_update')
def job_after_update_handler(mapper, connection, job):
    for attr in db.inspect(job).attrs:
        if attr.key != 'status':
            continue
        if not attr.load_history().has_changes():
            return
        if job.user.setting_job_status_mail_notification_level == UserSettingJobStatusMailNotificationLevel.NONE:
            return
        if job.user.setting_job_status_mail_notification_level == UserSettingJobStatusMailNotificationLevel.END:
            if job.status not in [JobStatus.COMPLETED, JobStatus.FAILED]:
                return
        msg = create_message(
            job.user.email,
            f'Status update for your Job "{job.title}"',
            'tasks/email/notification',
            job=job
        )
        mail.send(msg)
# endregion event_handlers


##############################################################################
# misc                                                                       #
##############################################################################
# region misc
@login.user_loader
def load_user(user_id):
    return User.query.get(int(user_id))
# endregion misc