'Invoice Amount',

        'Booked Amount',

        'Project',

        'Ticket',

        'Invoice',

        'Approval',

        'Contract',

        'Purchase Order',

    ]

    COL_COUNT = len(COLUMNS)

    def __init__(self,

                 date: datetime.date,

                 logger: logging.Logger,

    ) -> None:

        super().__init__()

        self.date = date

        self.logger = logger

    def init_styles(self) -> None:

        super().init_styles()

        self.style_widecol = self.replace_child(

            self.document.automaticstyles,

            odf.style.Style,

            name='WideCol',

        )

        self.style_widecol.setAttribute('family', 'table-column')

        self.style_widecol.addElement(odf.style.TableColumnProperties(

            self.balance_cell(row.end_balance),

            self.multiline_cell(sorted(projects)),

            self.multilink_cell(self._link_seq(row, 'rt-id')),

            self.multilink_cell(self._link_seq(row, 'invoice')),

            self.multilink_cell(self._link_seq(row, 'approval')),

            self.multilink_cell(self._link_seq(row, 'contract')),

            self.multilink_cell(self._link_seq(row, 'purchase-order')),

        )

class AgingReport(BaseReport):

    def __init__(self,

                 out_file: BinaryIO,

                 date: Optional[datetime.date]=None,

    ) -> None:

        if date is None:

            date = datetime.date.today()

        self.out_bin = out_file

        self.logger = logger.getChild(type(self).__name__)

    def run(self, groups: PostGroups) -> None:

        rows: List[AccrualPostings] = []

        for group in groups.values():

            if group.is_zero():

                # Cheap optimization: don't slice and dice groups we're not

                # going to report anyway.

                continue

            elif group.accrual_type is None:

                group = group.since_last_nonzero()

            else:

                # Filter out new accruals after the report date.

class BalanceReport(BaseReport):

    def _report(self, posts: AccrualPostings, index: int) -> Iterable[str]:

        posts = posts.since_last_nonzero()

        date_s = posts[0].meta.date.strftime('%Y-%m-%d')

        if index:

            yield ""

        yield f"{posts.invoice}:"

        yield f"  {posts.balance_at_cost()} outstanding since {date_s}"

class OutgoingReport(BaseReport):

        super().__init__(out_file)

    def _primary_rt_id(self, posts: AccrualPostings) -> rtutil.TicketAttachmentIds:

        rt_id = posts.rt_id

        if rt_id is None:

            raise ValueError("no rt-id links found")

        elif isinstance(rt_id, Sentinel):

            raise ValueError("multiple rt-id links found")

        parsed = rtutil.RT.parse(rt_id)

        if parsed is None:

            raise ValueError("rt-id is not a valid RT reference")

        else:

            return parsed

            for _, source in AccrualPostings.group_by_first_meta_link(postings, 'invoice')

            for key, group in source.make_consistent()

        }

    if args.report_type is not ReportType.AGING:

        groups = {

            key: posts for key, posts in groups.items() if not posts.is_paid()

        } or groups

    del postings

    report: Optional[BaseReport] = None

    output_path: Optional[Path] = None

    if args.report_type is ReportType.AGING:

            logger.error("unable to generate aging report: RT client is required")

        else:

            now = datetime.datetime.now()

            if args.output_file is None:

                args.output_file = Path(now.strftime('AgingReport_%Y-%m-%d_%H:%M.ods'))

                logger.info("Writing report to %s", args.output_file)

            out_bin = cliutil.bytes_output(args.output_file, stdout)

    elif args.report_type is ReportType.OUTGOING:

            logger.error("unable to generate outgoing report: RT client is required")

        else:

            out_file = cliutil.text_output(args.output_file, stdout)

    else:

        out_file = cliutil.text_output(args.output_file, stdout)

        report = BalanceReport(out_file)

    if report is None:

        returncode |= ReturnFlag.REPORT_ERRORS

    else:

        report.run(groups)

    return 0 if returncode == 0 else 16 + returncode

if __name__ == '__main__':

    exit(main())

#!/usr/bin/env python3

from setuptools import setup

setup(

    name='conservancy_beancount',

    description="Plugin, library, and reports for reading Conservancy's books",

    author='Software Freedom Conservancy',

    author_email='info@sfconservancy.org',

    license='GNU AGPLv3+',

    install_requires=[

        'babel>=2.6',  # Debian:python3-babel

        'beancount>=2.2',  # Debian:beancount

        # 1.4.1 crashes when trying to save some documents.

        'odfpy>=1.4.0,!=1.4.1',  # Debian:python3-odf

        'PyYAML>=3.0',  # Debian:python3-yaml

        'regex',  # Debian:python3-regex

        'rt>=2.0',

    consistent = related.make_consistent()

    _, actual = next(consistent)

    assert actual is related

    assert next(consistent, None) is None

def check_output(output, expect_patterns):

    output.seek(0)

    testutil.check_lines_match(iter(output), expect_patterns)

def run_outgoing(rt_id, postings, rt_client=None):

    if rt_client is None:

        rt_client = RTClient()

    if not isinstance(postings, core.RelatedPostings):

        postings = accruals_by_meta(postings, rt_id, 'rt-id', wrap_type=accrual.AccrualPostings)

    output = io.StringIO()

    report.run({rt_id: postings})

    return output

@pytest.mark.parametrize('invoice,expected', [

    ('rt:505/5050', "Zero balance outstanding since 2010-05-05"),

    ('rt:510/5100', "Zero balance outstanding since 2010-05-10"),

    ('rt:510/6100', "-280.00 USD outstanding since 2010-06-10"),

    ('rt://ticket/515/attachments/5150', "1,500.00 USD outstanding since 2010-05-15",),

])

def test_balance_report(accrual_postings, invoice, expected, caplog):

    related = accruals_by_meta(accrual_postings, invoice, wrap_type=accrual.AccrualPostings)

    output = io.StringIO()

    if today is None:

        today = datetime.date.today()

    postings = (

        post for post in postings

        if post.account.is_under('Assets:Receivable', 'Liabilities:Payable')

    )

    groups = {

        key: group

        for _, related in accrual.AccrualPostings.group_by_meta(postings, 'invoice')

        for key, group in related.make_consistent()

    }

    output = io.BytesIO()

    report.run(groups)

    return output

def test_aging_report(accrual_postings):

    output = run_aging_report(accrual_postings)

    check_aging_ods(output)

@pytest.mark.parametrize('date,recv_end,pay_end', [

    # Both these dates are chosen for their off-by-one potential:

    # the first is exactly 30 days after the 2010-06-10 payable;

    # the second is exactly 60 days after the 2010-05-15 receivable.

    (datetime.date(2010, 7, 10), 1, 5),