Mobilizon-Reshare-condividi.../mobilizon_reshare/cli/cli.py

262 lines
7.0 KiB
Python

import functools
import click
import uvicorn
from click import pass_context
from mobilizon_reshare.cli import safe_execution
from mobilizon_reshare.cli.commands.format.format import format_event
from mobilizon_reshare.cli.commands.list.list_event import list_events
from mobilizon_reshare.cli.commands.list.list_publication import list_publications
from mobilizon_reshare.cli.commands.publish.main import publish_command as publish_main
from mobilizon_reshare.cli.commands.pull.main import pull_command as pull_main
from mobilizon_reshare.cli.commands.recap.main import recap_command as recap_main
from mobilizon_reshare.cli.commands.retry.main import (
retry_event_command,
retry_publication_command,
)
from mobilizon_reshare.cli.commands.start.main import start_command as start_main
from mobilizon_reshare.config.command import CommandConfig
from mobilizon_reshare.config.config import current_version, get_settings
from mobilizon_reshare.config.publishers import publisher_names
from mobilizon_reshare.dataclasses.event import _EventPublicationStatus
from mobilizon_reshare.models.publication import PublicationStatus
from mobilizon_reshare.publishers import get_active_publishers
def test_settings(ctx, param, value):
if not value or ctx.resilient_parsing:
return
get_settings()
click.echo("OK!")
ctx.exit()
def print_version(ctx, param, value):
if not value or ctx.resilient_parsing:
return
click.echo(current_version())
ctx.exit()
def print_platforms(ctx, param, value):
if not value or ctx.resilient_parsing:
return
for platform in get_active_publishers():
click.echo(platform)
ctx.exit()
status_name_to_enum = {
"event": {
"waiting": _EventPublicationStatus.WAITING,
"completed": _EventPublicationStatus.COMPLETED,
"failed": _EventPublicationStatus.FAILED,
"partial": _EventPublicationStatus.PARTIAL,
"all": None,
},
"publication": {
"completed": PublicationStatus.COMPLETED,
"failed": PublicationStatus.FAILED,
"all": None,
},
}
from_date_option = click.option(
"-b",
"--begin",
type=click.DateTime(),
expose_value=True,
help="Include only events that begin after this datetime.",
)
to_date_option = click.option(
"-e",
"--end",
type=click.DateTime(),
expose_value=True,
help="Include only events that end before this datetime.",
)
event_status_argument = click.argument(
"status",
type=click.Choice(list(status_name_to_enum["event"].keys())),
default="all",
expose_value=True,
)
publication_status_argument = click.argument(
"status",
type=click.Choice(list(status_name_to_enum["publication"].keys())),
default="all",
expose_value=True,
)
event_uuid_option = click.option(
"-E",
"--event",
type=click.UUID,
expose_value=True,
help="Publish the given event.",
)
publication_uuid_option = click.option(
"-P",
"--publication",
type=click.UUID,
expose_value=True,
help="Publish the given publication.",
)
platform_name_option = click.option(
"-p",
"--platform",
type=str,
expose_value=True,
help="Publish to the given platform. This makes sense only for events.",
)
list_supported_option = click.option(
"--list-platforms",
is_flag=True,
callback=print_platforms,
expose_value=False,
is_eager=True,
help="Show all active platforms.",
)
test_configuration = click.option(
"-t",
"--test-configuration",
is_flag=True,
callback=test_settings,
expose_value=False,
is_eager=True,
help="Validate the current configuration.",
)
@click.group()
@test_configuration
@list_supported_option
@click.option(
"--version",
is_flag=True,
callback=print_version,
expose_value=False,
is_eager=True,
help="Show the current version.",
)
@pass_context
def mobilizon_reshare(obj):
pass
@mobilizon_reshare.command(
help="Synchronize and publish events. It is equivalent to running consecutively pull and then publish."
)
@click.option(
"--dry-run",
is_flag=True,
help="Prevents data to be published to platforms. WARNING: it will download and write new events to the database",
default=False,
)
def start(dry_run):
safe_execution(start_main, CommandConfig(dry_run=dry_run))
@mobilizon_reshare.command(help="Publish a recap of already published events.")
@click.option(
"--dry-run",
"dry_run",
is_flag=True,
help="Prevents data to be published to platforms. WARNING: it will download and write new events to the database",
default=False,
)
def recap(dry_run):
safe_execution(recap_main, CommandConfig(dry_run=dry_run))
@mobilizon_reshare.command(
help="Fetch the latest events from Mobilizon, store them if they are unknown, "
"update them if they are known and changed."
)
def pull():
safe_execution(pull_main,)
@mobilizon_reshare.command(
help="Select an event with the current configured strategy"
" and publish it to all active platforms."
)
@event_uuid_option
@publication_uuid_option
@platform_name_option
def publish():
safe_execution(publish_main,)
@mobilizon_reshare.group(help="Operations that pertain to events")
def event():
pass
@mobilizon_reshare.group(help="Operations that pertain to publications")
def publication():
pass
@event.command(help="Query for events in the database.", name="list")
@event_status_argument
@from_date_option
@to_date_option
def event_list(status, begin, end):
safe_execution(
functools.partial(
list_events, status_name_to_enum["event"][status], frm=begin, to=end,
),
)
@publication.command(help="Query for publications in the database.", name="list")
@publication_status_argument
@from_date_option
@to_date_option
def publication_list(status, begin, end):
safe_execution(
functools.partial(
list_publications,
status_name_to_enum["publication"][status],
frm=begin,
to=end,
),
)
@event.command(
help="Format and print event with EVENT-ID using the publisher's format named "
"PUBLISHER."
)
@click.argument("event-id", type=click.UUID)
@click.argument("publisher", type=click.Choice(publisher_names))
def format(
event_id, publisher,
):
safe_execution(functools.partial(format_event, event_id, publisher),)
@event.command(name="retry", help="Retries all the failed publications")
@click.argument("event-id", type=click.UUID)
def event_retry(event_id):
safe_execution(functools.partial(retry_event_command, event_id),)
@publication.command(name="retry", help="Retries a specific publication")
@click.argument("publication-id", type=click.UUID)
def publication_retry(publication_id):
safe_execution(functools.partial(retry_publication_command, publication_id),)
@mobilizon_reshare.command("web")
def web():
uvicorn.run(
"mobilizon_reshare.web.backend.main:app", host="0.0.0.0", port=8000, reload=True
)
if __name__ == "__main__":
mobilizon_reshare(obj={})