<?xml version="1.0" encoding="utf-8"?>
<ManualTopic ID="/baanerp/da/onlinemanual/000055" xml:lang="en">
	<Header>
		<Title xmlns:HTML="http://www.w3.org/TR/REC-html40">dadlllink_run</Title>
	</Header>
	<GeneralSection><GeneralSection><SectionTitle>DLL Usage description</SectionTitle>
			<Paragraph class="Default">This library contains functionality for export done messages, batches and batch lines to import and import done messages. These functions can be employed once the exchange links have been set up. When running a regular export at the source site export done messages are sent. These information from those messages is stored at the target site as batches and batch lines to import. When the data has been imported at the target site the batches and batch lines to import are deleted and an import done message is sent to the source site.</Paragraph>
			<Paragraph class="Default">Note on the function specifications: "iff" means "if and only if".</Paragraph>
		</GeneralSection>
		<GeneralSection><SectionTitle>DLL Prototypes</SectionTitle>
			<Formula space-and-orientation="indented-estimated"><Paragraph class="Default"> function extern long lrun.batch.to.import.exists(
                domain daxch.link link,
                domain daxch.long srun,
                domain daxch.pint stry )
 pre   : true post  : true return: True iff the batch to import specified by the
parameters
        exists.
 function extern long lrun.create.and.send.export.done.message(
                domain daxch.link subs,
                domain daxch.envi tenv,
                domain daxch.comp tcom,
                domain daxch.long srun,
                domain daxch.pint stry )
 pre   : The subscription defined by subs, tenv and tcom exists.
        srun &gt; 0, stry &gt; 0.
        The export done message defined by subs, tenv, tcom, srun and
        stry does not yet exist. post  : The export done message, specified by
the parameters,
        has been stored.
        If return then the export done message has accepted = yes,
        otherwise it has accepted = no.
        After calling this function one or more times, function
        lrun.end.sending() must be called. state : Before calling this function
a retry point must be set;
        after calling this function a commit must be given;
        no commit is given in this function. return: True iff the export done
message has been sent successfully;
        false means: the target environment is not available or the
        exchange link does not exist or has status inactive (source &amp;
        target). desc  : This function creates a new message, stores it, and
tries
        to send it.
 function extern long lrun.create.and.send.export.done.messages.for.
          batch(domain daxch.cxch sxch,
                domain daxch.cbat sbat,
                domain daxch.long srun,
                domain daxch.pint stry,
                domain daxch.comp startup.company )
 pre   : srun &gt; 0 and stry &gt; 0. post  : For all subscriptions containing the
batch (sxch, sbat), an
                export done message has been created.
                If return then all created export done messages have
                accepted = yes; otherwise one or more messages have
                accepted = no. state : Before calling this function a retry
point must be set;
                after calling this function a commit must be given;
                no commit is given in this function. return: OK iff for all
subscriptions containing the batch (if any)
                an export done message has been successfully.
 function extern long lrun.create.and.send.import.done.message(
                domain daxch.link link,
                domain daxch.long srun,
                domain daxch.pint stry,
                domain daxch.comp startup.company )
 pre   : link is an existing exchange link; srun &gt; 0 , stry &gt; 0. post  : If
return an import done message has been sent to the
                source site, otherwise a rejected import done message
                has been created. state : Before calling this function a retry
point must be set;
                after calling this function a commit must be given;
        no commit is given in this function. return: Return value of
lmess.send.import.done(), library
        dadlllink_mess. desc  : This function is used to send an import done
message for an
        active exchange link.
 function extern lrun.create.batch.line.to.import(
                domain daxch.link link,
                domain daxch.long srun,
                domain daxch.pint stry,
                domain daxch.batl batl,
                domain daxch.path sfil )
 pre   : The batch to import defined by link, srun and stry exists;
        usually the batch line to import defined by link, srun, stry,
        batl does not yet exist, but if it does this is not a problem;
        batl and sfil are filled. post  : The batch line to import, specified by
the parameters,
        has been created (duplicates are skipped). state : Before calling this
function a retry point must be set;
        after calling this function a commit must be given;
        no commit is given in this function.
 function extern long lrun.create.batch.to.import(
                domain daxch.link link,
                domain daxch.long srun,
                domain daxch.pint stry,
                domain daxch.yesno cmpr,
                domain daxch.yesno ctrl,
                domain daxch.sepa sepa,
                domain daxch.sepa ench,
                domain daxch.flag flags,
                domain daxch.yesno cmpl )
 pre   : srun &gt; 0, stry &gt; 0 , cmpr, ctrl and cmpl are filled. post  : If return
then the batch to import, specified by the
        parameters, has been created (duplicates are skipped). state : Before
calling this function a retry point must be set;
        after calling this function a commit must be given;
        no commit is given in this function. return: True iff the batch to
import created successfully;
        false means: the exchange link does not exist or has status
        inactive (source/target).
 function extern lrun.create.export.done.message(
                domain daxch.link subs,
                domain daxch.envi tenv,
                domain daxch.comp tcom,
                domain daxch.long srun,
                domain daxch.pint stry )
 pre   : The subscription defined by subs, tenv, tcom exists.
        srun &gt; 0, stry &gt; 0.
        The export done message defined by subs, tenv, tcom, srun and
        stry does not yet exist. post  : The export done message, specified by
the parameters,
        has been created; this message has accepted = no. state : Before calling
this function a retry point must be set;
        after calling this function a commit must be given;
        no commit is given in this function.
 function extern long lrun.delete.batch.to.import(
                domain daxch.link link,
                domain daxch.long srun,
                domain daxch.pint stry,
                domain daxch.comp startup.company )
 pre   : true post  : If return then the batch to import, specified by
        link, srun and stry has been deleted, and
        the batch lines to import also have been deleted. state : Before calling
this function a retry point must be set;
        after calling this function a commit must be given;
        no commit is given in this function. return: True iff a batch to import
has been deleted.
 function extern lrun.delete.batches.to.import.of.link(
                domain daxch.link link )
 pre   : true post  : The batches to import of the exchange link (if any)
        have been deleted, and the batch lines to import of the link
        have also been deleted. state : Before calling this function a retry
point must be set;
        after calling this function a commit must be given;
        no commit is given in this function.
 function extern long lrun.delete.export.done.message(
                domain daxch.link subs,
                domain daxch.long srun,
                domain daxch.pint stry,
                domain daxch.envi tenv,
                domain daxch.comp tcom )
 pre   : true post  : If return then the export done message specified by
        the function parameter has been deleted. state : Before calling this
function a retry point must be set;
        after calling this function a commit must be given;
        no commit is given in this function. return: True iff the export done
message could be deleted.
        (False means: export done message did not exist.)
 function extern lrun.delete.export.done.messages.of.subscription(
                domain daxch.link subs )
 pre   : true post  : The export done messages of the subscription (if any)
        have been deleted. state : Before calling this function a retry point
must be set;
        after calling this function a commit must be given;
        no commit is given in this function.
 function extern lrun.delete.rejected.import.done.messages.of.link(
                domain daxch.link link )
 pre   : true post..: The rejected import done messages of the exchange link
        (if any) have been deleted. state : Before calling this function a retry
point must be set;
        after calling this function a commit must be given;
        no commit is given in this function.
 function extern lrun.end.sending( )
 pre   : true post  : The messaging channel (required for sending messages from
        source environment to target environment or the other way
        around) has been closed. desc  : After calling this function it is still
possible to send
        new messages, but after doing so this function must be called
        once again.
 function extern long lrun.export.done.message.exists(
                domain daxch.link subs,
                domain daxch.envi tenv,
                domain daxch.comp tcom,
                domain daxch.long srun,
                domain daxch.pint stry,
                ref domain daxch.yesno accepted )
 pre   : true post  : If return then accepted shows whether the export done
message
        has been accepted by the target site,
        otherwise accepted is empty. return: True iff the export done message
defined by subs, tenv, tcom,
        srun and stry exists.
 function extern long lrun.export.done.message.exists.for.export.run(
                domain daxch.cxch sxch,
                domain daxch.cbat sbat,
                domain daxch.long srun,
                domain daxch.pint stry )
 pre   : true post  : true return: True iff an export done message exists for
the regular
        export run specified by the parameters. desc  : This function is used to
check whether an entry in the
        log table can be deleted.
        This should not be done when there is a rejected export done
        message, because this export done message will need the
        information from the log table when it is resent.
        This should also not be done when there is an accepted export
        done message, because otherwise duplicates may occur when
        running the export again.
 function extern long lrun.get.next.batch.to.import.from.active.link(
                domain daxch.cxch txch,
                domain daxch.cbat tbat,
                ref domain daxch.link link,
                ref domain daxch.long srun,
                ref domain daxch.pint stry,
                ref domain daxch.yesno cmpr,
                ref string sepa(),
                ref domain daxch.sepa ench,
                ref domain daxch.flag flags,
                domain daxch.comp startup.company )
 pre   : true post  : If return then
        - link, srun and stry identify an existing batch to import
          of an active exchange link having the specified target
          exchange scheme and batch, and having completed = yes;
          if there are multiple batches to import for the exchange
          link, the values of srun and stry returned will always
          be the lowest run/try existing for that exchange link;
        - cmpr, sepa and ench will contain the settings for the
          ascii files of the batch to import;
        - flags will contain the special flags (if any).
        If not return then the ref parameters are not filled. return: True iff
an active link exists with one or more batches to
        import messages for the specified target exchange scheme
        and batch.
 function extern long lrun.read.source.file.names(
                domain daxch.link link,
                domain daxch.long srun,
                domain daxch.pint stry,
                long no.batch.lines,
                const domain daxch.batl batch.line(),
                ref domain daxch.path file.name() fixed,
                domain daxch.comp startup.company )
 pre   : no.batch.lines &gt;= 0. post  : For all n &lt;= no.batch.lines:
        file.name(n) contains the name of the source file (including
        directory, but without the system name) for the batch line
        specified by link, source run, source try and batch.line(n);
        file.name(n) contains an empty string if this batch line to
        import could not be found. return: true
 function extern long lrun.resend.export.done.messages(
                domain daxch.link subs.f,
                domain daxch.link subs.t,
                domain daxch.envi tenv.f,
                domain daxch.envi tenv.t,
                domain daxch.comp tcom.f,
                domain daxch.comp tcom.t )
 pre   : true post  : If return then all export done messages (if any) of
        subscriptions in the specified range have accepted = yes;
        otherwise one or more export done messages have accepted = no state : A
retry point is set and a commit is given. return: Whether all export done
messages (if any) have been sent
        successfully. desc  : The function tries to resend all export done
messages
        of subscriptions in the specified range having accepted = no.
 function extern long lrun.resend.export.done.messages.detailed(
                domain daxch.cxch sxch.f,
                domain daxch.cxch sxch.t,
                domain daxch.cbat sbat.f,
                domain daxch.cbat sbat.t,
                domain daxch.envi tenv.f,
                domain daxch.envi tenv.t,
                domain daxch.comp tcom.f,
                domain daxch.comp tcom.t,
                domain daxch.cxch txch.f,
                domain daxch.cxch txch.t,
                domain daxch.cbat tbat.f,
                domain daxch.cbat tbat.t )
 pre   : true post  : If return then all export done messages (if any) of
        subscriptions in the specified range have accepted = yes;
        otherwise one or more export done messages have accepted = no. state : A
retry point is set and a commit is given. return: Whether all export done
messages (if any) have been sent
        successfully. desc  : The function tries to resend all export done
messages
        of subscriptions in the specified range having accepted = no.
 function extern long lrun.resend.import.done.messages(
                domain daxch.link link.f,
                domain daxch.link link.t )
 pre   : true post  : If return then all rejected import done messages in the
        specified range (if any) have been sent successfully;
        otherwise one or more messages could not be delivered.
        All rejected import done messages sent successfully are deleted state :
A retry point is set and a commit is given. return: True iff all rejected import
done messages in the specified
        range (if any) have been sent successfully.
 function extern long lrun.resend.import.done.messages.detailed(
                domain daxch.envi senv.f,
                domain daxch.envi senv.t,
                domain daxch.comp scom.f,
                domain daxch.comp scom.t,
                domain daxch.cxch sxch.f,
                domain daxch.cxch sxch.t,
                domain daxch.cbat sbat.f,
                domain daxch.cbat sbat.t,
                domain daxch.cxch txch.f,
                domain daxch.cxch txch.t,
                domain daxch.cbat tbat.f,
                domain daxch.cbat tbat.t )
 pre   : true post  : If return then all rejected import done messages in the
        specified range (if any) have been sent successfully;
        otherwise one or more messages could not be delivered.
        All rejected import done messages sent successfully are deleted state :
A retry point is set and a commit is given. return: True iff all rejected import
done messages in the specified
        range (if any) have been sent successfully.
 function extern long lrun.send.current.import.done.message.and.commit()
 pre   : Record of daxch406 is filled with an existing rejected import
        done message. post  : If return = OK then the import done message has
been sent
        successfully and has been deleted. state : A retry point is set and a
commit is given (if return = OK). return: Return value of
lmess.send.import.done() in dadlllink_mess.
 function extern long lrun.send.export.done.messages.of.subscription(
                domain daxch.link subs,
                domain daxch.envi tenv,
                domain daxch.comp tcom )
 pre   : true post  : If return = OK then the message and all preceding messages
        have been sent successfully, else one or more of the messages
        for the exchange link could not be sent successfully.
        (Note: a message for run/try n will only be sent if all
        messages of the same subscription having run/try &lt; n have
        been sent successfully.)
        After calling this function one or more times, function
        lrun.end.sending() must be called. state : Before calling this function
a retry point must be set;
        after calling this function a commit must be given;
        no commit is given in this function. return: Possible return values are
the same as return values for
        function lmess.send.export.done.message() in library
        dadlllink_mess. risk  : If the system goes down during this process, an
inconsistency
        between source and target system may exist (because a two
        phase commit is not available for multi-site).
 function extern long lrun.set.batch.to.import.to.completed(
                domain daxch.link link,
                domain daxch.long srun,
                domain daxch.pint stry )
 pre   : true post  : If return then the batch to import, specified by link,
srun
        and stry has been updated: 'Completed' has been set to yes. state :
Before calling this function a retry point must be set;
        after calling this function a commit must be given;
        no commit is given in this function. return: True iff the batch to
import exists and has been updated.
</Paragraph>
			</Formula>
		</GeneralSection>
	</GeneralSection>
	<RelatedTopics><SectionTitle>
                              Related topics
                           </SectionTitle>
		<RelTopic><Link href="/baanerp/da/onlinemanual/000102" role="manual">Libraries</Link>
		</RelTopic>
	</RelatedTopics>
</ManualTopic>
