/**
  * Opens a dialog and then sets the status for all motions.
  *
  * @param motions The motions to change
  */
 public async setStateOfMultiple(motions: ViewMotion[]): Promise<void> {
     const title = this.translate.instant('This will set the following state for all selected motions:');
     const choices = this.workflowRepo.getWorkflowStatesForMotions(motions).map(workflowState => ({
         id: workflowState.id,
         label: workflowState.name
     }));
     const selectedChoice = await this.choiceService.open(title, choices);
     if (selectedChoice) {
         await this.repo.setMultiState(motions, selectedChoice.items as number);
     }
 }

            this.repo.getViewModelObservable(params.id).subscribe(newViewMotion => {
                this.motion = newViewMotion;

                this.paragraphs = this.repo
                    .getTextParagraphs(this.motion, true, this.lineLength)
                    .map((paragraph: string, index: number) => {
                        return {
                            paragraphNo: index,
                            safeHtml: this.sanitizer.bypassSecurityTrustHtml(paragraph),
                            rawHtml: this.lineNumbering.stripLineNumbers(paragraph)
                        };
                    });
            });

 /**
  * Creates the pdfMake definitions for a row of the call List table
  *
  * @param motion
  * @returns pdfmakre definitions
  */
 private createCallListRow(motion: ViewMotion): object {
     return [
         {
             text: motion.sort_parent_id ? '' : motion.identifierOrTitle
         },
         { text: motion.sort_parent_id ? motion.identifierOrTitle : '' },
         { text: motion.submitters.length ? motion.submitters.map(s => s.short_name).join(', ') : '' },
         { text: motion.title },
         {
             text: motion.recommendation ? this.motionRepo.getExtendedRecommendationLabel(motion) : ''
         },
         { text: '' }
     ];
 }

 /**
  * Opens a dialog and changes the motionBlock for all given motions.
  *
  * @param motions The motions for which to change the motionBlock
  */
 public async setMotionBlock(motions: ViewMotion[]): Promise<void> {
     const title = this.translate.instant('This will set the following motion block for all selected motions:');
     const clearChoice = 'Clear motion block';
     const selectedChoice = await this.choiceService.open(
         title,
         this.motionBlockRepo.getViewModelList(),
         false,
         null,
         clearChoice
     );
     if (selectedChoice) {
         for (const motion of motions) {
             const blockId = selectedChoice.action ? null : (selectedChoice.items as number);
             await this.repo.update({ motion_block_id: blockId }, motion);
         }
     }
 }

 /**
  * Returns the motions corresponding to a category
  *
  * @param category target
  * @returns all motions in the category
  */
 public motionsInCategory(category: Category): ViewMotion[] {
     const coll = new Intl.Collator(this.translate.currentLang);
     return this.motionRepo
         .getViewModelList()
         .filter(m => m.category_id === category.id)
         .sort((motion1, motion2) => {
             if (motion1.identifier && motion2.identifier) {
                 return coll.compare(motion1.identifier, motion2.identifier);
             } else if (motion1.identifier) {
                 return 1;
             } else if (motion2.identifier) {
                 return -1;
             } else {
                 return coll.compare(motion1.getTitle(), motion2.getTitle());
             }
         });
 }

 /**
  * Triggers a pdf creation for this poll's ballots.
  * There will be 8 ballots per page.
  * Each ballot will contain:
  * - the event name and logo
  * - a first, bold line with a title. Defaults to the label Motion, the identifier,
  *   and the current number of polls for this motion (if more than one)
  * - a subtitle. A second, short (two lines, 90 characters) clarification for
  *   the ballot. Defaults to the beginning of the motion's title
  * - the options 'yes', 'no', 'abstain' translated to the client's language.
  *
  * @param motionPoll: The poll this ballot refers to
  * @param title (optional) a different title
  * @param subtitle (optional) a different subtitle
  */
 public printBallots(motionPoll: MotionPoll, title?: string, subtitle?: string): void {
     const motion = this.motionRepo.getViewModel(motionPoll.motion_id);
     const fileName = `${this.translate.instant('Motion')} - ${motion.identifier} - ${this.translate.instant(
         'ballot-paper'
     )}`;
     if (!title) {
         title = `${this.translate.instant('Motion')} - ${motion.identifier}`;
         if (motion.motion.polls.length > 1) {
             title += ` (${this.translate.instant('Vote')} ${motion.motion.polls.length})`;
         }
     }
     if (!subtitle) {
         subtitle = motion.title;
     }
     if (subtitle.length > 90) {
         subtitle = subtitle.substring(0, 90) + '...';
     }
     this.pdfService.downloadWithBallotPaper(this.getContent(title, subtitle), fileName, this.logo);
 }

 /**
  * Opens a dialog and sets the category for all given motions.
  *
  * @param motions The motions to change
  */
 public async setCategory(motions: ViewMotion[]): Promise<void> {
     const title = this.translate.instant('This will set the following category for all selected motions:');
     const clearChoice = this.translate.instant('No category');
     const selectedChoice = await this.choiceService.open(
         title,
         this.categoryRepo.sortViewCategoriesByConfig(this.categoryRepo.getViewModelList()),
         false,
         null,
         clearChoice
     );
     if (selectedChoice) {
         for (const motion of motions) {
             await this.repo.update(
                 { category_id: selectedChoice.action ? null : (selectedChoice.items as number) },
                 motion
             );
         }
     }
 }

    /**
     * Saves the amendment and navigates to detail view of this amendment
     *
     * @returns {Promise<void>}
     */
    public async saveAmendment(): Promise<void> {
        const amendedParagraphs = this.paragraphs.map(
            (paragraph: ParagraphToChoose, index: number): string => {
                if (index === this.contentForm.value.selectedParagraph) {
                    return this.contentForm.value.text;
                } else {
                    return null;
                }
            }
        );
        const newMotionValues = {
            ...this.metaInfoForm.value,
            ...this.contentForm.value,
            title: this.translate.instant('Amendment to') + ' ' + this.motion.identifier,
            parent_id: this.motion.id,
            amendment_paragraphs: amendedParagraphs
        };

        const motion = new CreateMotion();
        motion.deserialize(newMotionValues);

        const response = await this.repo.create(motion);
        this.router.navigate(['./motions/' + response.id]);
    }

    /**
     * Creates the MetaInfoTable
     *
     * @param motion the target motion
     * @returns doc def for the meta infos
     */
    private createMetaInfoTable(motion: ViewMotion, crMode: ChangeRecoMode, infoToExport?: InfoToExport[]): object {
        const metaTableBody = [];

        // submitters
        if (!infoToExport || infoToExport.includes('submitters')) {
            const submitters = motion.submitters
                .map(submitter => {
                    return submitter.full_name;
                })
                .join(', ');

            metaTableBody.push([
                {
                    text: `${this.translate.instant('Submitters')}:`,
                    style: 'boldText'
                },
                {
                    text: submitters
                }
            ]);
        }

        // state
        if (!infoToExport || infoToExport.includes('state')) {
            metaTableBody.push([
                {
                    text: `${this.translate.instant('State')}:`,
                    style: 'boldText'
                },
                {
                    text: this.motionRepo.getExtendedStateLabel(motion)
                }
            ]);
        }

        // recommendation
        if (motion.recommendation && (!infoToExport || infoToExport.includes('recommendation'))) {
            let recommendationByText: string;

            if (motion.isStatuteAmendment()) {
                recommendationByText = this.configService.instant('motions_statute_recommendations_by');
            } else {
                recommendationByText = this.configService.instant('motions_recommendations_by');
            }

            metaTableBody.push([
                {
                    text: `${recommendationByText}:`,
                    style: 'boldText'
                },
                {
                    text: this.motionRepo.getExtendedRecommendationLabel(motion)
                }
            ]);
        }

        // category
        if (motion.category && (!infoToExport || infoToExport.includes('category'))) {
            metaTableBody.push([
                {
                    text: `${this.translate.instant('Category')}:`,
                    style: 'boldText'
                },
                {
                    text: motion.category.prefix
                        ? `${motion.category.prefix} - ${motion.category.name}`
                        : `${motion.category.name}`
                }
            ]);
        }

        // tags
        if (motion.tags.length && (!infoToExport || infoToExport.includes('tags'))) {
            const tags = motion.tags
                .map(tag => {
                    return tag;
                })
                .join(', ');

            metaTableBody.push([
                {
                    text: `${this.translate.instant('Tags')}:`,
                    style: 'boldText'
                },
                {
                    text: tags
                }
            ]);
        }

        // motion block
        if (motion.motion_block && (!infoToExport || infoToExport.includes('block'))) {
            metaTableBody.push([
                {
//.........这里部分代码省略.........

 public getMotionTitle(motion: MotionTitleInformation): string {
     return this.motionRepo.getTitle(motion);
 }