About RSNAST00
I meet a problem that is when I try to run RSNAST00 with input an existed object number (a billing document)and output type (such as ZORG), I continuously get "0 output were processed in total." So I couldn't see the proper results. (But I can see this invoice output with the object number and output type by using VF31).
Could you please tell me what the problem is when I run RSNAST00? Thanks a lot.
Your output type should be configured to repeat output and you should select 'Send Again' checkbox in the selection sreen of program RSNAST00.
Similar Messages
-
Hi,
How ABOUT NAST RSNAST00 this are linked with ABAP Code?
Example if any?
Thanks
AviHi
Check this one The simplest way to create IDocs, is to write an ABAP. The individual ABAP can either be a triggering ABAP which runs at certain events, e.g. every night, or it can be an ABAP which does the complete IDoc creation from scratch.
Triggering ABAP
A triggering ABAP would simply try to determine which IDocs need sending and call the appropriate IDoc creation routines.
ABAP creates the whole IDoc
You may also imagine the ABAP to do all the job. As this is mostly reinventing the wheel, it is not really recommended and should be reserved to situation, where the other solution do not provide an appropriate mean.
1.1 NAST Messages Based Outbound IDocs
You can use the R/3 message concept to trigger IDocs the same way as you trigger SAPscript printing.
One of the key tables in R/3 is the table NAST. This table records reminders written by applications. Those reminders are called messages.
Applications write messages to NAST, which will be processed by a message handler
Every time when an applications sees the necessity to pass information to a third party. a message is written to NAST. A message handler will eventually check the entries in the table and cause an appropriate action.
EDI uses the same mechanism as printing
The concept of NAST messages has originally been designed for triggering SAPscript printing. The very same mechanism is used for IDocs, where the IDoc processor replaces the print task, as an IDoc is only the paperless form of a printed document.
Condition technique can mostly be used
The messages are usually be created using the condition technique, a mechanism available to all major R/3 applications.
Printing, EDI and ALE use the same trigger
The conditions are set up the same way for any output media. So you may define a condition for printing a document and then just change the output media from printer to IDoc/EDI or ALE.
Figure 1: Communicating with message via table NAST
NAST messages are created by application by calling function module MESSAGING
Creating NAST messages is a standard functionality in most of the SAP core applications. Those applications - e.g. VA01, ME21 - perform calls to the central function module MESSAGING of group V61B. The function module uses customizing entries, mainly those of the tables T681* to T685*.
NAST contains object key, sender and receiver
A NAST output message is stored as a single record in the table NAST. The record stores all information that is necessary to create an IDoc. This includes mainly an object key to identify the processed object and application to the message handler and the sender and receiver information.
Programs RSNAST00 and RSNASTED provide versatile subroutines for NAST processing
The messages are typically processed by
FORM ENTRY in PROGRAM RSNAST00.
If we are dealing with printing or faxing and
FORM EDI_PROCESSING in PROGRAM RSNASTED.
If we are dealing with IDocs
FORM ALE_PROCESSING in PROGRAM RSNASTED.
If we are dealing with ALE.
The following piece of code does principally the same thing as RSNAST00 does and makes full use of all customizing settings for message handling.
FORM einzelnachricht IN PROGRAM RSNAST00
TABLES: NAST.
SELECT * FROM NAST ...
PERFORM einzelnachricht IN PROGRAM RSNAST00
Programs are customized in table TNAPR
The processing routine for the respective media and message is customized in the table TNAPR. This table records the name of a FORM routine, which processes the message for the chosen media and the name of an ABAP where this FORM is found.
1.2 The RSNAST00 ABAP
The ABAP RSNAST00 is the standard ABAP, which is used to collect unprocessed NAST message and to execute the assigned action.
RSNAST00 is the standard batch collector for messages
RSNAST00 can be executed as a collector batch run, that eventually looks for unprocessed IDocs. The usual way of doing that is to define a batch-run job with transaction SM37. This job has to be set for periodic processing and start a program that triggers the IDoc re-sending.
RSNAST00 processes only messages of a certain status
Cave! RSNAST00 will only look for IDocs which are set to NAST-VSZTP = '1' or '2' (Time of processing). VSZPT = '3' or '4' is ignored by RSNAST00.
For batch execution a selection variant is required
Start RSNAST00 in the foreground first and find the parameters that match your required selection criteria. Save them as a VARIANT and then define the periodic batch job using the variant.
If RSNAST00 does not meet 100% your needs you can create an own program similar to RSNAST00. The only requirement for this program are two steps:
Read the NAST entry to process into structure NAST
tables nast.
data: subrc like sy-subrc.....
select from NAST where .......
then call FORM einzelnachricht(rsnast00) to process the record
PERFORM einzelnachricht(rsnast00) USING subrc.
1.3 Sending IDocs Via RSNASTED
Standard R/3 provides you with powerful routines, to trigger, prepare and send out IDocs in a controlled way. There are only a few rare cases, where you do not want to send IDocs the standard way.
The ABAP RSNAST00 is the standard routine to send IDocs from entries in the message control. This program can be called directly, from a batch routine with variant or you can call the FORM einzelnachricht_screen(RSNAST00) from any other program, while having the structure NAST correctly filled with all necessary information.
RSNAST00 determines if it is IDoc or SAPscript etc.
If there is an entry in table NAST, RSNAST00 looks up the associated processing routine in table TNAPR. If it is to send an IDoc with standard means, this will usually be the routine RSNASTED(EDI_PROCESSING) or RSNASTED(ALE_PROCESSING) in the case of ALE distribution.
RSNASTED processes IDocs
RSNASTED itself determines the associated IDoc outbound function module, executes it to fill the EDIDx tables and passes the prepared IDoc to the port.
You can call the standard processing routines from any ABAP, by executing the following call to the routine. You only have to make sure that the structure NAST is declared with the tables statement in the calling routine and that you fill at least the key part and the routine (TNAPR) information before.
TABLES NAST.
NAST-MANDT = SY-MANDT.
NAST-KSCHL = 'ZEDIK'.
NAST-KAPPL = 'V1'.
NAST-OBJKY = '0012345678'.
NAST-PARNR = 'D012345678'.
PERFORM einzelnachricht_screen(RSNAST00).
Calling einzelnachricht_screen determines how the message is processed. If you want to force the IDoc-processing you can call it directly:
TNAPR-PROGN = ''.
TNAPR-ROUTN = 'ENTRY'.
PERFORM edi_processing(RSNASTED).
1.4 Sending IDocs Via RSNAST00
Here is the principle flow how RSNAST00 processes messages for IDocs.
Figure 2: Process logic of RSNAST00 ABAP
1.5 Workflow Based Outbound IDocs
Unfortunately, there are application that do not create messages. This is especially true for master data applications. However, most applications fire a workflow event during update, which can easily be used to trigger the IDoc distribution.
SWE_EVENT_CREATE
Many SAP R/3 applications issue a call to the function SWE_EVENT_CREATE during update. This function module ignites a simple workflow event.
Workflow is a call to a function module
Technically a workflow event is a timed call to a function module, which takes the issuing event as the key to process a subsequent action.
Applications with change documents always trigger workflow events
If an application writes regular change documents (ger.: Änderungsbelege) to the database, it will issue automatically a workflow event. This event is triggered from within the function CHANGEDOCUMENT_CLOSE. The change document workflow event is always triggered, independent of the case whether a change document is actually written.
Workflow coupling can be done by utility functions
In order to make use of the workflow for IDoc processing, you do not have to go through the cumbersome workflow design procedure as it is described in the workflow documentation. For the mentioned purpose, you can register the workflow handler from the menu, which says Event Coupling from the BALD transaction.
Workflow cannot easily be restarted
Triggering the IDoc from a workflow event has a disadvantage: if the IDoc has to be repeated for some reason, the event cannot be repeated easily. This is due to the nature of a workflow event, which is triggered usually from a precedent action. Therefore you have to find an own way how to make sure that the IDoc is actually generated, even in the case of an error. Practically this is not a very big problem for IDocs. In most cases the creation of the IDoc will always take place. If there is a problem, then the IDoc would be stored in the IDoc base with a respective status. It will shown in transaction WE05 and can be resend from there.</b>
Thanks
Manju -
Spool requests are being sent the the B9 printer queue(RSNAST00).
Hi gurus,
has anyone found a fix for this issue? i'm currently experiencing the same issue and would like to know how i can fix this..
Spool requests are being sent the the B9 printer queue. Most spool requests are for one page, when there are spool requests for multiple pages these spool requests take longer to create, in the meantime, other spool requests that are single pages are going to the printer queue. This creates and "out-of-vendor-order" issue during printing.
The out of vendor order sequencing creates a significant level of work effort for the business users to resort the printed copies in order to prepare the documents for mailing. A change is required to eliminate this manual effort.
Development has indicated an enhancement could be made to the RSNAST00 program where only those print jobs for application "MR" with transmission "1" (for print) would be gathered in groups of "X" number of documents to create one spool, prior to creating the spool, a check would be made to see if the next document was for the same vendor, if so the next document/s would be included in the same spool, when a new vendor was found, a new spool would be created.
To temporarily fix the issue the jobs have been placed on "no execute" and the support team is identifing the chargebacks and RTV created during the week, manually running the RSNAST00 program in groups of 500 - 800 documents, ensuring all doucments for a vendor a sent in the same spool request.Post Author: Stephen@Azzu
CA Forum: General
Nobody know the answer to this one? Stephen@Azzu:Here's a good one...I'm using Crysal Reports XI (fully service packed) and the reports I have created are being used in a VB.Net application. I have no problems whatsoever in printing the reports, everything is fine. However, when the report is sent to the printer, the printer queue displays 'document' as the, err, document name. I'd like it to say something more relevant, such as the document number the user selected.So I've tried setting the ReportDocument.Name but wait, it's read only!? How about the summary info? No change. Filename? No change either. I've browsed the internet, searched the knowledge base and found nothing. So my question is this...How do I get the printer queue to display an appropriate name for my document?Stephen -
Hi friends,
What is RSNAST00 and in what reference we use this. In one of our old programs they were using this RSNAST00 to print out the report output. Now I am asked to add email functionality to it. Is there any option in RSNAST00 to do email attachment. So I have to attach the output as pdf file to send external email. Please help me in doing this.
SUBMIT RSNAST00 VIA SELECTION-SCREEN WITH S_KAPPL IN R_KAPPL
WITH S_OBJKY IN R_OBJKY
WITH S_KSCHL IN R_KSCHL
WITH S_NACHA IN R_NACHA
WITH P_AGAIN EQ ' '
WITH P_PRINT EQ '4_A1'
AND RETURN.
Thanks
Veni.Hi Suresh,
Thank you for the information. After I select the output type as 'ZCOM' and Tranmission Medium '1' for print out and executed. I go to sp01 transaction to see the output. I know how to use function module 'SO_NEW_DOCUMENT_ATT_SEND_API1'.
But Can you please let me know how to create the spool request, as I donot have idea about it. I am attaching the code I have. Please help me.
Thanks
Veni.
REPORT ZSDRSHIP LINE-SIZE 248 LINE-COUNT 65 MESSAGE-ID ZV
NO STANDARD PAGE HEADING.
Data Declaration
*Tables
TABLES: VBRK, "Billing: Header Data
ITCPO, "Sapscript Output Interface
T001, "Company Codes
SADR, "Address Management: Company Data
VBPA, "Sales Document: Partner
KNA1, "General Data in Customer Master
LFA1, "Vendor master (general section)
VBRP, "Billing: Item Data
DNAST, "Output status, display fields
T005T, "Country Names
EIKP, "Export/Import header data
T618T, "Modes of Transport: Descriptions
ZMAT, "Classification of Material Numbers
T001W, "Plants/Branches
T005U, "Taxes: Region Key: Texts
NAST. "Message status
selection screen for the program RSNAST00 run.
RANGES: R_KAPPL FOR DNAST-KAPPL,
R_OBJKY FOR NAST-OBJKY,
R_KSCHL FOR NAST-KSCHL,
R_NACHA FOR NAST-NACHA,
R_LDEST FOR NAST-LDEST.
Internal tables.
DATA: BEGIN OF ITAB_VBRK OCCURS 100,
VBELN LIKE VBRK-VBELN,
NETWR LIKE VBRK-NETWR,
BUKRS LIKE VBRK-BUKRS,
EXNUM LIKE VBRK-EXNUM,
END OF ITAB_VBRK.
DATA: BEGIN OF ITAB_VBRP OCCURS 50,
MATNR LIKE VBRP-MATNR,
FKIMG LIKE VBRP-FKIMG,
NETWR LIKE VBRP-NETWR,
WERKS LIKE VBRP-WERKS,
END OF ITAB_VBRP.
DATA: BEGIN OF ITAB_ZMAT OCCURS 10,
ZMATNR LIKE ZMAT-ZMATNR,
FKIMG LIKE VBRP-FKIMG,
NETWR LIKE VBRP-NETWR,
END OF ITAB_ZMAT.
DATA: BEGIN OF FTAB OCCURS 100,
IND TYPE C,
VBELN(10) TYPE N,
NETWR LIKE VBRK-NETWR,
BUKRS LIKE VBRK-BUKRS,
EXNUM LIKE VBRK-EXNUM,
END OF FTAB.
DATA: IND TYPE C,
CNT1 TYPE I,
IPAGE TYPE I,
I_WERKS LIKE VBRP-WERKS VALUE ' '.
Program Selections
SELECT-OPTIONS: SDATE FOR VBRK-FKDAT.
Initialization
INITIALIZATION.
Initialization for the program RSNAST00 run.
R_KAPPL-SIGN = 'I'.
R_KAPPL-OPTION = 'EQ'.
R_KAPPL-LOW = 'V3'.
R_KAPPL-HIGH = ' '.
APPEND R_KAPPL.
CLEAR R_KAPPL.
R_KSCHL-SIGN = 'I'.
R_KSCHL-OPTION = 'EQ'.
R_KSCHL-LOW = 'ZCOM'.
R_KSCHL-HIGH = ' '.
APPEND R_KSCHL.
CLEAR R_KSCHL.
R_NACHA-SIGN = 'I'.
R_NACHA-OPTION = 'EQ'.
R_NACHA-LOW = '1'.
R_NACHA-HIGH = ' '.
APPEND R_NACHA.
CLEAR R_NACHA.
Start-of-selection
START-OF-SELECTION.
SELECT VBELN NETWR BUKRS EXNUM FROM VBRK INTO TABLE ITAB_VBRK
WHERE FKART EQ 'F8'
AND FKDAT IN SDATE.
COMMIT WORK.
PERFORM OUTPUT.
AT USER-COMMAND.
CASE SY-UCOMM.
WHEN 'PRIN'.
PERFORM READ_DATA.
PERFORM PRINT_DATA.
WHEN 'SELE'.
PERFORM SELECT_DATA.
WHEN 'DETA'.
PERFORM READ_DATA.
PERFORM DISPLAY_DATA.
ENDCASE.
TOP-OF-PAGE
TOP-OF-PAGE.
PERFORM HEADINGS.
TOP-OF-PAGE DURING LINE-SELECTION.
CASE SY-UCOMM.
WHEN 'SELE'.
PERFORM HEADINGS.
WHEN 'DETA'.
PERFORM HEADINGS1.
ENDCASE.
*& Form OUTPUT
text
--> p1 text
<-- p2 text
FORM OUTPUT.
SET PF-STATUS 'NORM'.
LOOP AT ITAB_VBRK.
WRITE: /01 SY-VLINE,
02 IND AS CHECKBOX,
03 SY-VLINE,
04 ITAB_VBRK-VBELN,
15 SY-VLINE,
16 ITAB_VBRK-NETWR,
51 SY-VLINE.
ENDLOOP.
ULINE /(51).
ENDFORM. " OUTPUT
*& Form READ_DATA
text
--> p1 text
<-- p2 text
FORM READ_DATA.
CNT1 = 6.
IPAGE = 1.
REFRESH FTAB.
LOOP AT ITAB_VBRK.
READ LINE CNT1 OF PAGE IPAGE FIELD VALUE IND INTO FTAB-IND.
READ LINE CNT1 OF PAGE IPAGE FIELD VALUE
ITAB_VBRK-VBELN INTO FTAB-VBELN.
FTAB-BUKRS = ITAB_VBRK-BUKRS.
FTAB-NETWR = ITAB_VBRK-NETWR.
FTAB-EXNUM = ITAB_VBRK-EXNUM.
APPEND FTAB.
CLEAR FTAB.
CNT1 = CNT1 + 1.
IF CNT1 > 65.
IPAGE = IPAGE + 1.
CNT1 = 6. "Vish - 10/03/00
ENDIF.
ENDLOOP.
ENDFORM. " READ_DATA
*& Form PRINT_DATA
text
--> p1 text
<-- p2 text
FORM PRINT_DATA.
LOOP AT FTAB.
IF FTAB-IND = 'X'.
REFRESH R_OBJKY.
R_OBJKY-SIGN = 'I'.
R_OBJKY-OPTION = 'EQ'.
R_OBJKY-LOW = FTAB-VBELN.
R_OBJKY-HIGH = ' '.
APPEND R_OBJKY.
CLEAR R_OBJKY.
SUBMIT RSNAST00 VIA SELECTION-SCREEN WITH S_KAPPL IN R_KAPPL
WITH S_OBJKY IN R_OBJKY
WITH S_KSCHL IN R_KSCHL
WITH S_NACHA IN R_NACHA
WITH P_AGAIN EQ ' '
WITH P_PRINT EQ '4_A1'
AND RETURN.
IF FTAB-NETWR GE 2500.
PERFORM GET_DATA.
PERFORM PRINT_FORM.
ENDIF.
ENDIF.
ENDLOOP.
ENDFORM. " PRINT_DATA
*& Form PRINT_FORM
text
--> p1 text
<-- p2 text
FORM PRINT_FORM.
ITCPO-TDIMMED = 'X'.
ITCPO-TDDELETE = 'X'.
ITCPO-TDPROGRAM = SY-REPID.
ITCPO-TDDEST = '5_A1'.
CALL FUNCTION 'OPEN_FORM'
EXPORTING
FORM = 'Z_SHIPPERS'
LANGUAGE = SY-LANGU
OPTIONS = ITCPO
EXCEPTIONS
CANCELED = 1
DEVICE = 2
FORM = 3
OPTIONS = 4
UNCLOSED = 5
OTHERS = 6.
LOOP AT ITAB_ZMAT.
CALL FUNCTION 'WRITE_FORM'
EXPORTING
ELEMENT = 'ITEM_DATA'
FUNCTION = 'SET'
TYPE = 'BODY'
WINDOW = 'MAIN'
IMPORTING
PENDING_LINES =
EXCEPTIONS
ELEMENT = 1
FUNCTION = 2
TYPE = 3
UNOPENED = 4
UNSTARTED = 5
WINDOW = 6
OTHERS = 7.
ENDLOOP.
CALL FUNCTION 'CLOSE_FORM'
EXCEPTIONS
UNOPENED = 1
OTHERS = 2.
IF SY-SUBRC EQ 0.
MESSAGE I355 WITH FTAB-VBELN.
ENDIF.
ENDFORM. " PRINT_FORM
*& Form SELECT_DATA
text
--> p1 text
<-- p2 text
FORM SELECT_DATA.
SY-LSIND = 0.
IF IND = 'X'.
IND = ' '.
ELSEIF IND = ' '.
IND = 'X'.
ENDIF.
PERFORM OUTPUT.
ENDFORM. " SELECT_DATA
*& Form GET_DATA
text
--> p1 text
<-- p2 text
FORM GET_DATA.
CLEAR: T001, SADR, VBPA, LFA1, KNA1, T005T, EIKP, T618T, I_WERKS.
REFRESH: ITAB_VBRP, ITAB_ZMAT.
SELECT SINGLE ADRNR BUTXT FROM T001 INTO (T001-ADRNR, T001-BUTXT)
WHERE BUKRS EQ FTAB-BUKRS.
SELECT SINGLE * FROM SADR WHERE ADRNR EQ T001-ADRNR
AND NATIO EQ SPACE.
SELECT SINGLE LIFNR FROM VBPA INTO VBPA-LIFNR
WHERE VBELN EQ FTAB-VBELN
AND POSNR = '000000'
AND PARVW = 'SP'.
SELECT SINGLE * FROM LFA1 WHERE LIFNR = VBPA-LIFNR.
SELECT SINGLE KUNNR FROM VBPA INTO VBPA-KUNNR
WHERE VBELN EQ FTAB-VBELN
AND POSNR = '000000'
AND PARVW = 'WE'.
SELECT SINGLE * FROM KNA1 WHERE KUNNR = VBPA-KUNNR.
SELECT SINGLE * FROM T005T WHERE SPRAS = 'E'
AND LAND1 = KNA1-LAND1.
SELECT SINGLE * FROM EIKP WHERE EXNUM = FTAB-EXNUM.
SELECT SINGLE * FROM T618T WHERE SPRAS = 'E'
AND LAND1 = EIKP-ALAND
AND EXPVZ = EIKP-EXPVZ.
SELECT MATNR FKIMG NETWR WERKS FROM VBRP INTO TABLE ITAB_VBRP
WHERE VBELN = FTAB-VBELN.
LOOP AT ITAB_VBRP.
IF I_WERKS EQ ' '.
I_WERKS = ITAB_VBRP-WERKS.
SELECT SINGLE * FROM T001W WHERE WERKS = I_WERKS.
SELECT SINGLE * FROM T005U WHERE SPRAS = 'E'
AND LAND1 = T001W-LAND1
AND BLAND = T001W-REGIO.
ENDIF.
SELECT SINGLE ZMATNR FROM ZMAT INTO ZMAT-ZMATNR
WHERE MATNR = ITAB_VBRP-MATNR.
IF SY-SUBRC EQ 0.
MOVE ZMAT-ZMATNR TO ITAB_ZMAT-ZMATNR.
MOVE ITAB_VBRP-FKIMG TO ITAB_ZMAT-FKIMG.
MOVE ITAB_VBRP-NETWR TO ITAB_ZMAT-NETWR.
COLLECT ITAB_ZMAT.
CLEAR ITAB_ZMAT.
ELSE.
MESSAGE I356 WITH ITAB_VBRP-MATNR.
ENDIF.
ENDLOOP.
ENDFORM. " GET_DATA
*& Form HEADINGS
text
--> p1 text
<-- p2 text
FORM HEADINGS.
FORMAT COLOR COL_HEADING.
WRITE: 'AMERICA, INC.',
/ 'List of Commercial Invoices'.
ULINE /(51).
FORMAT COLOR 2.
WRITE: /01 SY-VLINE,
03 SY-VLINE,
04 TEXT-001,
15 SY-VLINE,
16 TEXT-002,
51 SY-VLINE,
52 ' ' COLOR OFF.
ULINE /(51).
ENDFORM. " HEADINGS
*& Form DISPLAY_DATA
text
--> p1 text
<-- p2 text
FORM DISPLAY_DATA.
SET PF-STATUS 'NORM1'.
LOOP AT FTAB.
IF FTAB-IND = 'X'.
REFRESH ITAB_VBRP.
SELECT MATNR FKIMG NETWR WERKS FROM VBRP INTO TABLE ITAB_VBRP
WHERE VBELN = FTAB-VBELN.
WRITE:/ 'Details of Commercial Invoice:'COLOR 4, FTAB-VBELN COLOR 4.
ULINE /(56).
LOOP AT ITAB_VBRP.
WRITE: /01 SY-VLINE,
02 ITAB_VBRP-MATNR,
20 SY-VLINE,
21 ITAB_VBRP-NETWR,
56 SY-VLINE,
57 ' ' COLOR OFF.
ENDLOOP.
ULINE /(56).
ENDIF.
ENDLOOP.
ENDFORM. " DISPLAY_DATA
*& Form HEADINGS1
text
--> p1 text
<-- p2 text
FORM HEADINGS1.
FORMAT COLOR COL_HEADING.
WRITE: 'AMERICA, INC.',
/ 'Commercial Invoice Details.'.
ULINE /(56).
FORMAT COLOR 2.
WRITE: /01 SY-VLINE,
02 TEXT-003,
20 SY-VLINE,
21 TEXT-004,
56 SY-VLINE,
57 ' ' COLOR OFF.
ULINE /(56).
ENDFORM. " HEADINGS1 -
Hi ABAPers,
I´m new on IDoc, so I need somebody to help me.
I wish know how can I find where an IDoc is "generated". That is, where the MASTER_IDOC_DISTRIBUTE function is called.
My issue is an IDoc generated during the purchase order process (I guess that in the MIRO), I´ve already tried debug and stop in the above function without sucess.
Any help is welcomed.
Thanks,
Charles>
Charles Oliveira wrote:
> Hi Krishnendu,
>
> The debug didn't stop in these functions too.
>
> I don't understand so well about IDoc, but what I've, corrects me if something is wrong, is an IDoc (outbound) that is generated in a BADI or an USEREXIT, during the MIRO.
>
> I need know what's this EXIT or BADI, to make some modifications in the information that is passed to IDoc.
>
> Thank you and if you know anything more to help me, I would appreciate.
>
>
> Regards,
> Charles
There is a Concept called Message Control , Here Output type is attached to the IDoc message type and IDoc type. You will maintain this In WE20 partner profile part , in the outbound section.
and at the same time you will maitain the Output type in NACE ,
In NACE you will Configure the output type with medium as ALE/IDOC or EDI
and Program RSNASTED , i am not sure what is used in your case ? , it may be same or it may be Different and custom one.
you go to program RSNAST00 ,
in this you can go to line # 1327 ,
perform (tnapr-ronam) in program (tnapr-pgnam) using returncode
us_screen
if found.
here you keep a break point. and Go to MIRO tigger the output type. if it stops well and good.
if not start Debugging using /H in the messages screen , and Trigger the output by saving it.and then activate the Update Debugging from Menu Debugging->Update Debugging
then F8. it will stop exactly the above perform , and there you check.
and also if you know the output type you can check the Medium and Program used for processing the output. -
Hi..
I want to know how RSNAST00 calls the respective function module in the ABAB Coding.?
For Example in case of say any Delivery Document Number, when we run RSNAST00 for it giving the proper message type(say in our case LD00 with ALE as a medium)then at what point of time is the function module (say IDOC_OUTPUT_DELIVRY)called in that program. I didnt see a direct call of the function module as such in the program.
I hope I have made myself clear in framing a question.
Thanks.Hi Subhash,
As most of reply said, RSNAST00 will call the subroutine ALE_PROCESSING or EDI_PROCESSING in the program RSNASTED. But this is link is defined in your message determination .. If you know place where you maintain the Program name script name for Printing the documents with output type.. it is the same place you maintian the subroutine and program (i.e. ALE_PROCESSING or EDI_PROCESSING in the program RSNASTED based on the output medium; A- Ale, 6-EDI).
So when you run RSNAST00, it basically selects all the output records ready for procesing from NAST table based on the seletion parameters you have give. From there it identifies the program and subroutine to be called, calls that particular subroutine (for printing it will be your ENTRY subroutine in Driver program) with the Nast record. RSNAST00 Job is done once it calls the subroutine..
Now the Subroutine being called takes the job of printing/faxing/ creating & sending the iDoc.
In case of ALE/EDI, your ALE_PRocessing & EDI_procssing routine determines the FM to be called in the following way.
It picks up the Message partner from the NAST record and check whether there is partner profile defined for that in WE20. If not defined error.. if defined, it will determine the FM to be called based on information given in the Output control tab and processed code give there (Process code is linked to your FM that fill the iDoc). Then it passes the iDoc internal table to ALE layer for further processing which stores that on DB and sends it our bsed on the WE20 configuration..
Hope this gives you the clear picture about how the iDoc is generated from output control.
Regards,
Nagaraju Chidurupalli. -
About modularization techniques
hi,,
can anybody send me the details about modularization techniques ?
mainly i want differences between INCLUDES and FUNCTION MODULES.
MACROS and SUBROUTINES.Hi
Purpose of modularization is: 1) Organizing your ABAP Code 2) Limit maintenance cost by coding every thing only once and making your ABAP code easier to understand.
Modularization techniques:
1) Organizing your ABAP code can be done by using INCLUDE reports and local MACRO's (DEFINE statement). Typical examples can be found in Module Pools and Function Groups with TOP-includes and special includes for PBO events, PAI events et cetera. You can discuss if using subroutines, functions or methods is also part of this type of modularization technique. At this moment, most ABAP programmers use subroutines partly as a means to create some sort of main line in their program, thus limiting large chunks of ABAP code. Regarding MACRO's there are some special problems, especially that they don't improve readability of ABAP coding, and you can not debug them.
2)Here, we are talkin about ABAP PROCEDURES: a) Subroutines, b) Functions and c) Methods
- 2a) Subroutines: can be used locally and globally (external subroutine calls). Subroutines have a formal interface ( USING, CHANGING, TABLES parameters). The interface parameters can be passed BY VALUE or BY REFERENCE. Data that is defined within a subroutine (FROM ... ENDFORM.) is local: lifetime and visibility is limited to the moment the subroutine is called. External Subroutines are subroutines that are called from another program. Typical example can be found in the way SAPscript and SMARTforms printprograms are called by RSNAST00. External Subroutines can be grouped into Subroutine Pools.
- 2b) Functions: are part of function groups. They are designed for global use and have a unique name. Function Modules also have a formal interface using IMPORTING, EXPORTING, CHANGING and TABLES parameters. The interface parameters can be passed BY VALUE or BY REFERENCE. Specific EXCEPTIONS can be defined for error handling. A function module can also have local data.
In theory, a function module can only use data a)from the interface parameters, b) defined locally in the function module and c) defined globally in the function group. However, it is possible to see global data from calling programs using field-symbols.
Remote Function Modules are function modules that can be called from other SAP or NON-SAP systems. BAPI's are examples of RFC-enabled function modules.
Function Groups and Function Modules are maintained using transaction SE37 (or SE80).
- 2c) Methods: are part of CLASSES. Here we are talking about ABAP Objects, supporting inheritance, instantiation, encapsulation, polymorphism, events, Interfaces, visibility sections (PUBLIC, PROTECTED, PRIVATE) and lifetime options STATIC and INSTANCE.
Classes can be defined locally or globally: a) Local Classes are classes, defined as part of an ABAP program. They can be used only within this program. b) The functionality of Global Classes is identical, but these classes are maintained using the Class Builder (SE24 or SE80).
The name of a method is not unique; you always need the name of the object to create the unique name. As a result, several classes will have exactly the same method name.
Methods also have a formal interface using IMPORTING, EXPORTING, CHANGING and RETURNING parameters. The interface parameters can be passed BY VALUE or BY REFERENCE. Specific EXCEPTIONS can be defined for error handling. A method can also have local data.
In general, using classes is considered a much better alternative to using subroutines and function modules, especially with regards to maintenance costs. Actually, you do not need subroutines anymore. Function Modules are only needed is some cases, for example as RFC's because the classes don't support remote calls.
One limitation of ABAP Classes is that they do not support dynpro's. This means that you always need a report/module pool/function group if you want to create screens.
Within methods, several types of obsolete ABAP statements are not allowed like: ON CHANGE OF, TABLES and OCCURS.
Consider that new tools and options like Web Dynpro, Unit Testing, Shared Objects, Exception Classes can only be understood when having the knowledge of ABAP OO. If you are debugging new SAP transactions, you'll see that they are also programmed using ABAP Objects.
Processing blocks that are called from ABAP programs:
1. Subroutines
2. Function modules
3. Methods
Procedures
Procedures contain a set of statements, and are called from other ABAP programs.
The processing blocks that you call from ABAP programs are called procedures
You define procedures in ABAP programs. When the program is generated, they remain as standalone modules. You can call procedures in the program in which they are defined, or from external programs. Procedures have an interface for passing data, and can also contain local data.
ABAP contains the following kinds of procedures:
Subroutines
Subroutines are principally for local modularization, that is, they are generally called from the program in which they are defined. You can use subroutines to write functions that are used repeatedly within a program. You can define subroutines in any ABAP program.
Function Modules
Function modules are for global modularization, that is, they are always called from a different program. Function modules contain functions that are used in the same form by many different programs. They are important in the R/3 System for encapsulating processing logic and making it reusable. Function modules must be defined in a function group, and can be called from any program.
Methods
Methods describe the functions and behavior of classes and their instances in ABAP Objects. Methods must be defined in classes. When you call them, you must observe certain special rules of object-oriented programming.
Subroutines
Subroutines are procedures that you can define in any ABAP program and also call from any program. Subroutines are normally called internally, that is, they contain sections of code or algorithms that are used frequently locally. If you want a function to be reusable throughout the system, use a function module.
subroutine is a block of code introduced by FORM and concluded by ENDFORM.
FORM [USING ... [)] ... ] [CHANGING... [)] ... ].
ENDFORM.
subroutines cannot be nested. You should therefore place your subroutine definitions at the end of the program
Calling Subroutines
PERFORM... .
Subroutines can call other subroutines (nested calls) and may also call themselves (recursive calls). Once a subroutine has finished running, the calling program carries on processing after the PERFORM statement. You can use the USING and CHANGING additions to supply values to the parameter interface of the subroutine.
Function Modules
Function modules are procedures that are defined in function groups (special ABAP programs with type F) and can be called from any ABAP program. Function groups act as containers for function modules that logically belong together.
Unlike subroutines, you do not define function modules in the source code of your program. Instead, you use the Function Builder. The actual ABAP interface definition remains hidden from the programmer. You can define the input parameters of a function module as optional. You can also assign default values to them. Function modules also support exception handling. This allows you to catch certain errors while the function module is running.
Function groups are containers for function modules. You cannot execute a function group. When you call an function module, the system loads the whole of its function group into the internal session of the calling program (if it has not already been loaded).
This is used by the system to create the components of the group (main program and corresponding include programs). When you create a function group or function module in the Function Builder , the main program and include programs are generated automatically.
The main program SAPL contains nothing but the INCLUDE statements for the following include programs:
LTOP. This contains the FUNCTION-POOL statement (equivalent for a function group of the REPORT or PROGRAM statement) and global data declarations for the entire function group.
LUXX. This contains further INCLUDE statements for the include programs
LU01, LU02, ... These includes contain the actual function modules.
The include programs LF01, LF02, ... can contain the coding of subroutines that can be called with internal subroutine calls from all function modules of the group.
All of the function modules in a function group can access the global data of the group. For this reason, you should place all function modules that use the same data in a single function group.
Function modules can have the following interface parameters:
Import parameters. These must be supplied with data when you call the function module, unless they are flagged as optional. You cannot change them in the function module.
Export parameters. These pass data from the function module back to the calling program. Export parameters are always optional. You do not have to receive them in your program.
Changing parameters. These must be supplied with data when you call the function module, unless they are flagged as optional. They can be changed in the function module. The changed values are then returned to the calling program.
Tables parameters. You use these to pass internal tables. They are treated like CHANGING parameters. However, you can also pass internal tables with other parameters if you specify the parameter type appropriately.
You can specify the types of the interface parameters, either by referring to ABAP Dictionary types or elementary ABAP types. When you call a function module, you must ensure that the actual parameter and the interface parameters are compatible.
Interface parameters are, by default, passed by value. However, they can also be passed by reference. Tables parameters can only be passed by reference. You can assign default values to optional importing and changing parameters. If an optional parameter is not passed in a function module call, it either has an initial value, or is set to the default value.
Exceptions are used to handle errors that occur in function modules. The calling program checks whether any errors have occurred and then takes action accordingly.
Calling Function Modules in ABAP
To call a function module, use the CALL FUNCTION statement:
CALL FUNCTION [EXCEPTIONS e1 = r 1.... e n = r n ].
You can specify the name of the function module either as a literal or a variable. Each interface parameter is explicitly assigned to an actual parameter . You can assign a return value to each exception . The assignment always takes the form = . The equals sign is not an assignment operator in this context.
After EXPORTING, you must supply all non-optional import parameters with values appropriate to their type. You can supply values to optional import parameters if you wish.
After IMPORTING, you can receive the export parameters from the function module by assigning them to variables of the appropriate type.
After CHANGING or TABLES, you must supply values to all of the non-optional changing or tables parameters. When the function module has finished running, the changed values are passed back to the actual parameters. You can supply values to optional changing or tables parameters if you wish.
You can use the EXCEPTIONS option to handle the exceptions of the function module. If an exception is raised while the function module is running, the system terminates the function module and does not pass any values from the function module to the program, except those that were passed by reference. If is specified in the EXCEPTION option, the calling program handles the exception by assigning to SY-SUBRC. must be a numeric literal.
If you specify of ERROR_MESSAGE in the exception list you can influence the message handling of function modules. Normally, you should only call messages in function modules using the MESSAGE ... RAISING statement. With ERROR_MESSAGE you can force the system to treat messages that are called without the RAISING option in a function module as follows:
Messages of classes S, I, and W are ignored (but written to the log in a background job).
Messages of classes E and A stop the function module as if the exception ERROR_MESSAGE had occurred (SY-SUBRC is set to ).
If you specify OTHERS after EXCEPTIONS, the system assigns a single return code to all other exceptions that you have not specified explicitly in the list.
You can use the same number for several exceptions.
You can trigger exceptions in the function module using either the RAISE or the MESSAGE ... RAISING statement. If the calling program handles the exception, both statements return control to the program. The MESSAGE ..... RAISING statement does not display a message in this case. Instead, it sets the following system fields:
1. Message class ® SY-MSGID
2. Message type ® SY-MSGTY
3. Message number ® SY-MSGNO
4. SY-MSGV1 to SY-MSGV4 (contents of fields to , included in a message).
You can use the system fields to trigger the message from the calling program.
Raising Exceptions
There are two ABAP statements for raising exceptions. They can only be used in function modules:
RAISE .
and
MESSAGE..... RAISING .
The effect of these statements depends on whether the calling program handles the exception or not. If the name of the exception or OTHERS occurs in the EXCEPTIONS addition of the CALL FUNCTION statement, the exception is handled by the calling program.
If the calling program does not handle the exception
The RAISE statement terminates the program and switches to debugging mode.
The MESSAGE ..... RAISING statement display the specified message. How the processing continues depends on the message type.
If the calling program handles the exception, both statements return control to the program. No values are transferred. The MESSAGE ..... RAISING statement does not display a message. Instead, it fills the system fields SY-MSGID, SY-MSGTY, SY-MSGNO, and SY-MSGV1 to SY-MSGV4.
Remote Function Modules
To implement a remote function module in ABAP, perform the following steps:
1. Register the module as remotely callable in the RFC server system.
In the function module Administration screen (transaction code SE37), set the field Can be called via REMOTE CALL. Registering a module as remote causes an RFC stub to be generated for it.
Asynchronous remote function calls (aRFCs) are similar to transactional RFCs, in that the user does not have to wait for their completion before continuing the calling dialog. There are three characteristics, however, that distinguish asynchronous RFCs from transactional RFCs:
When the caller starts an asynchronous RFC, the called server must be available to accept the request.
The parameters of asynchronous RFCs are not logged to the database, but sent directly to the server.
Asynchronous RFCs allow the user to carry on an interactive dialog with the remote system.
The calling program can receive results from the asynchronous RFC.
You can use asynchronous remote function calls whenever you need to establish communication with a remote system, but do not want to wait for the functions result before continuing processing. Asynchronous RFCs can also be sent to the same system. In this case, the system opens a new session (or window) and allows you to switch back and forth between the calling dialog and the called session.
To start a remote function call asynchronously, use the following syntax:
CALL FUNCTION RemoteFunction STARTING NEW TASK taskname
Destination ...
EXPORTING...
TABLES ...
EXCEPTIONS...
The following calling parameters are available:
TABLES
passes references to internal tables. All table parameters of the function module must contain values.
EXPORTING
passes values of fields and field strings from the calling program to the function module. In the function module, the correponding formal parameters are defined as import parameters.
EXCEPTIONS
see Using Pre-Defined Exceptions for RFC
RECEIVE RESULTS FROM FUNCTION func is used within a FORM routine to receive the results of an asynchronous remote function call. The following receiving parameters are available:
1. IMPORTING
2. TABLES
3. EXCEPTIONS
The addition KEEPING TASK prevents an asynchronous connection from being closed after receiving the results of the processing. The relevant remote context (roll area) is kept for re-use until the caller terminates the connection.
Call a transaction asynchronally and display it in an amodal window:
DATA: MSG_TEXT(80) TYPE C. "Message text
Asynchronous call to transaction SM59 ->
Create a new session
CALL FUNCTION ABAP4_CALL_TRANSACTION STARTING NEW TASK TEST
DESTINATION NONE
EXPORTING
TCODE = SM59
EXCEPTIONS
COMMUNICATION_FAILURE = 1 MESSAGE MSG_TEXT
SYSTEM_FAILURE = 2 MESSAGE MSG_TEXT
IF SY-SUBRC NE 0.
WRITE: MSG_TEXT.
ELSE.
WRITE: O.K.
ENDIF.
You must not use IMPORTING when calling aRFCs.
Transactional Remote Function Calls
RfcInstallTransactionControlinstalls four functions to control transactional behaviour.
RFC_ON_CHECK_TIDis called when a local transaction is starting.
RfcCreateTransID Get a unique transaction-ID for calling an
ABAP function module using the transactional RFC Interface
RfcIndirectCall Call an ABAP function module using the
transactional RFC Interface
RFC_ON_COMMIT is called when a local transaction ends.
RFC_ON_CONFIRM_TID is called when a local transaction is
completed.
RFC_ON_ROLLBACK is call
ed when a local transaction ends with
failure.
RFC_ONCALL
INCLUDE AND MACROS:
When you modularize source code, you place a sequence of ABAP statements in a module. Then, instead of placing all of the statements in your main program, you just call the module.
Include programs are global R/3 Repository objects. They are solely for modularizing source code, and have no parameter interface.
They have the following functions:
Library:Include programs allow you to use the same source code in different programs. For example, this can be useful if you have lengthy data declarations that you want to use in different programs.
Order. Include programs allow you to manage complex programs in an orderly way. Function groups and module pools use include programs to store parts of the program that belong together. The ABAP Workbench supports you extensively when you create such complex programs by creating the include programs automatically and by assigning them unique names.
Creating Your Own Include Programs
If you create an include program yourself, you must assign it the type I in its program attributes.
An include program cannot run independently, but must be built into other programs. Include programs can contain other includes.
The only restrictions for writing the source code of include programs are:
Include programs cannot call themselves.
Include programs must contain complete statements.
The INCLUDE statement has the same effect as copying the source code of the include program into the program. In the syntax check, the contents of the include program are also analyzed. Include programs are not loaded at runtime, but are expanded when the program is generated. Once the program has been generated, the load version contains static versions of all of its includes. If you subsequently change an include program, the programs that use it are automatically regenerated.
***INCLUDE STARTTXT.
WRITE: / 'Program started by', SY-UNAME,/ 'on host', SY-HOST, 'date:', SY-DATUM, 'time:', SY-UZEIT.ULINE.
We can then include this program in any other ABAP program to display a standard list header.
PROGRAM SAPMZTST.INCLUDE STARTTXT.
This could produce the following output:
Program started by KELLERH
on host ds0025 date: 03/19/1998 time: 09:00:39
Macros
If you want to reuse the same set of statements more than once in a program, you can include them in a macro. For example, this can be useful for long calculations or complex WRITE statements. You can only use a macro within the program in which it is defined, and it can only be called in lines of the program following its definition.
The following statement block defines a macro :
DEFINE .
END-OF-DEFINITION.
Macros do not belong to the definition part of the program. This means that the DEFINE...END-OF-DEFINITION block is not interpreted before the processing blocks in the program. At the same time, however, macros are not operational statements that are executed within a processing block at runtime. When the program is generated, macro definitions are not taken into account at the point at which they are defined
A macro definition inserts a form of shortcut at any point in a program and can be used at any subsequent point in the program. As the programmer, you must ensure that the macro definition occurs in the program before the macro itself is used. Particular care is required if you use both macros and include programs, since not all include programs are included in the syntax check (exception: TOP include).
To use a macro, use the following form:
When the program is generated, the system replaces by the defined statements and each placeholder &i by the parameter
. You can use macros within macros. However, a macro cannot call itself.
DATA: RESULT TYPE I,N1 TYPE I VALUE 5,N2 TYPE I VALUE 6.
DEFINE OPERATION. RESULT = &1 &2 &3.OUTPUT &1 &2 &3 RESULT.END-OF-DEFINITION.
DEFINE OUTPUT. WRITE: / 'The result of &1 &2 &3 is', &4.END-OF-DEFINITION.
OPERATION 4 + 3.OPERATION 2 ** 7.OPERATION N2 - N1.
The produces the following output:
The result of 4 + 3 is 7
The result of 2 ** 7 is 128
The result of N2 - N1 is 1
Inserting the macro changes nothing in the generated form of the program.
Check this link
http://www.sapbrainsonline.com/FAQs/TECHNICAL/SAP_ABAP_MODULARIZATION_FAQ.html
http://help.sap.com/saphelp_40b/helpdata/en/9f/db970e35c111d1829f0000e829fbfe/content.htm
http://help.sap.com/saphelp_40b/helpdata/en/9f/db970e35c111d1829f0000e829fbfe/content.htm
Regards
Pavan
Message was edited by:
Pavan praveen
Message was edited by:
Pavan praveen -
Adobe Bridge in Photoshop - How to install Bridge and camera raw? And what is it all about?
Hi everyone! I am actually in love with this adobe photoshop. I used PSCS2 before, but later on upgraded to CS4. But I feel tired in upgrading to CS5.
One time, I found a tutorial in youtube about camera raw, and would really want to use it. But I was wondering how to install the camera raw. I believe camera raw is a plugin? so I downloaded the plugin here, installed it in my PS. I downloaded a file Camera Raw.8bi and paste it on my C drive - C:\Program Files\Adobe\Photoshop CS4\Plug-ins\File Formats.
I now am very confused, how will I open it? I do not have adobe bridge! After I installed the camera raw, I opened my PS. I clicked the file>then browse in bridge. I had an error, it's "error 2 photoshop11 undefined". Which is what I thought, I might have done something wrong with installing it.
My question is, do you still need adobe bridge installed in order to use camera raw?
If yes, how does it work? How am I suppose to open camera raw?
If no, how am I going to open camera raw without bridge?
And also, where will I download adobe bridge? I cannot find one here for CS4, only adobe bridge for CS5. I am wondering, is it okay to install adobe bridge CS5 and use it with my PS CS4?
I badly need help!WebDAV (Web-based Distributed Authoring and Versioning) is a set of extensions to HTTP/1.1.
The main difference from FTP as far as I can see is that it allows you to edit documents on a remote web server.
WebDAV was used by the Apple server - MobileMe but is not generally supported by hosting services.
Using WebDAV you can mount a directory locally. This was how iDisk worked on your Mac and you could drag files onto it to upload them to the remote directory.
With WebDAV, a number of users can share a directory which is why its used in local networks but presents security problems when using a remote server.
If you are into file sharing rather than publishing, Dropbox or its new rival SugarSync are more appropriate. -
A few days ago i bought the macbook pro in a Providence. In late Summer i will come back to my Country - Ukraine. I would like to know about a tax for my
laptop. Can i return tax? Through the TAX FREE or return in airport? What should i do?You need to talk with the tax authorities in the countries to which you traveled and that of your home country. We are all end-users liek you and not Apple agents.
-
ok i have a advent roma laptop with window 7. my itunes used to work fine, completely. every time i plugged in my ipod it was ok. recently my ipod was not working so i never bothered with itunes, however i have movies/tv prog that i purchased and would like to view them. i have an ipod nano from about 5 years ago, the problem with thet is, it switches on, but the circular control panel does nothing, all you can do is lock and unlock it - nothing else.
i tried to download new version of itunes, then uninstalled my origonal version, incase it was corrupted etc, i then again tried to down load new version and also version that is windows 64bit. still when i select the downlaod to open as son as it is finnished nothing happens. and now my desktop shortcut has dissapeared. before when it was there, id double click it, nothing, right click to open it, nothing.
im not the best technically minded but i just dont see what im doing wrong here, please helpPerhaps it would be helpful for you to view the page source code of this page
http://www.alanwork.com/
As you can see, the submenu code links are immediately below the top level code, and are
wrapped in their own <UL> </UL> tag pairs.
Hope that helps -
Vendor payments and debts about an asset
Dear sap colleages
I need to know these information about an ASSET:
Purchased orders,
Items from purchase orders,
which of these items i've received, i've paid (also date), i've not paid ( amount of debt related to asset)
payments in advanced (date),
wich of these payments have been cleared (clearing date) and wich not,
who is the vendor,
other expenses (such as delivery)
the amount of taxes,
invoices related and NOT RELATED TO purchase order
payments without invoice
Which transactions do i need to follow?
or
Which document flow?
or
Which tables? Wich keys?
or
Is there a standard report that can give me such information?
Any documentation and/or code will be appreciated.
I need to program a report to integrate all these information.
Thanks and Kind RegardsHi,
Refer to T.code AW01N - Asset Explorer .
Additionally you cna also refer to SAP Standard reports in Asset Accounting
Accounting - Financial Accounting - Fixed Assets - Information System - Reports on Asset Accounting
Please let me know if you need more information.
Assign points if useful.
Regards
Sridhar M -
I cannot receive email properly on either my IPad or my IPhone. I have had them for over a year and they have always worked fine. Until three days ago, when they both started acting up. On the IPad, when I open mail, it says it is downloading about 1,700 emails. At the very end, which takes quite a while to get to, I finally get the most recent ones. The IPad is sending emails just fine.
On my IPhone, when I open mail, it says it is downloading 100 emails, but it doesn't do that. And it gives me no new emails at all. The IPhone is sending email just fine.
I have already deleted the email accounts on both devices and reinstalled them. I've contacted the Internet service provider and verified all the right settings. The Outlook email on my desktop is working perfectly.WMV is a heavily-compressed format/CODEC, and the processing time will depend on several factors:
Your CPU, which is not that powerful in your case
Your I/O sub-system, which is likely a single HDD on your laptop
The source footage. What is your source footage?
Any Effects added to that footage. Do you have any Effects?
Each of those will have an impact on the time required.
The trial has only one main limitation - the watermark. Now, there are some components, that have to be activated, but are not with the trial, but they would be evident with Import of your source footage, if it's an issue.
Good luck,
Hunt -
I have had my IPAD2 for quite a while but haven't activated my cellular data for about a year. I am now trying to activate and when I go to cellular data, turn it on and try to tap view account i just get a message that says "connection to server lost". I could swear the last time I used cellular data you would see the signal in the upper left corner and I only see "no service" there, I am in a location where I know I should have service. Is there something I should do to my IPAD? I tried resetting, I tried clearing cookies and history in Safari (after reading a post n these discussions). I don't know what to do next. My IOS version is 6.1.3. I did go into Network from the general tab and I see it says "SIM not provisioned". HELP and Thank you in advance.
Hello Theresa818,
Thank you for using Apple Support Communities!
It sounds like the cellular data will not activate for some reason on the iPad.
I found this article that will help you resolve this issue here, named iPad (Wi-Fi + Cellular Models): Troubleshooting a cellular data connection, found here http://support.apple.com/kb/TS4249
Check for a carrier settings update.
Update your iPad.
Toggle the Cellular Data setting off and on under Settings > Cellular Data.
Restart your iPad.
Tap Settings > General > About. Locate the Carrier entry and make sure that your carrier is correct.
If your SIM card has SIM PIN enabled, try turning it off: Tap Settings > Cellular Data > SIM PIN.
Make sure you're in an area of good coverage. If the cellular data connection works in another area, contact your carrier to report the original affected area.
Reset network settings: Tap Settings > General > Reset > Reset Network Settings.
Restore the iPad as new.
If none of the above steps resolves the issue, make an appointment at an Apple Retail Store, contact your carrier, or contact AppleCare to troubleshoot further.
I know you may have done one or two of the steps here, so you can skip those.
Take care,
Sterling -
Doubt about report FBL5N of screen field:Open items and Cleared items
hi
i know the report FBL5N is use DDF LDB and the report work flow is BSID->BKFP->BSEG
but i don't know to differentiate Open Items and Cleared items in this report.
Open items and Cleared items stand for a field flag in these table (BSID,BKFP,BSEG )? if true the field is?
or they must be calc in program ? if true what about calc rules?
waiting for help! thank you!Hi,
Here is the difference in Open Items and Cleared Items.
In FI first the document is Open (when it is posted) so the entry is made in table BSID. Once the document is cleared, it will move from BSID to BSAD. And for Cleared item you will see Clearing Document no and Clearing date values updated (these are blank when the item is open).
The only difference in Open and Cleared is via Clearing Document and Clearing Date. If the values are present, it means document is cleared.
Hope this helps.
ashish
Message was edited by:
Ashish Gundawar -
Follow up on an old thread about memory utilization
This thread was active a few months ago, unfortunately its taken me until now
for me to have enough spare time to craft a response.
From: SMTP%"[email protected]" 3-SEP-1996 16:52:00.72
To: [email protected]
CC:
Subj: Re: memory utilization
As a general rule, I would agree that memory utilzation problems tend to be
developer-induced. I believe that is generally true for most development
environments. However, this developer was having a little trouble finding
out how NOT to induce them. After scouring the documentation for any
references to object destructors, or clearing memory, or garbage collection,
or freeing objects, or anything else we could think of, all we found was how
to clear the rows from an Array object. We did find some reference to
setting the object to NIL, but no indication that this was necessary for the
memory to be freed.
I believe the documentation, and probably some Tech-Notes, address the issue of
freeing memory.
Automatic memory management frees a memory object when no references to the
memory
object exist. Since references are the reason that a memory object lives,
removing
the references is the only way that memory objects can be freed. This is why the
manuals and Tech-Notes talk about setting references to NIL (I.E. freeing memory
in an automatic system is done by NILing references and not by calling freeing
routines.) This is not an absolute requirement (as you have probably noticed
that
most things are freed even without setting references to NIL) but it accelerates
the freeing of 'dead' objects and reduces the memory utilization because it
tends
to carry around less 'dead' objects.
It is my understanding that in this environment, the development tool
(Forte') claims to handle memory utilization and garbage collection for you.
If that is the case, then it is my opinion that it shoud be nearly
impossible for the developer to create memory-leakage problems without going
outside the tool and allocating the memory directly. If that is not the
case, then we should have destructor methods available to us so that we can
handle them correctly. I know when I am finished with an object, and I
would have no problem calling a "destroy" or "cleanup" method. In fact, I
would prefer that to just wondering if Forte' will take care of it for me.
It is actually quite easy to create memory leaks. Here are some examples:
Have a heap attribute in a service object. Keep inserting things into
the heap and never take them out (I.E. forgot to take them out). Since
service objects are always live, everything in the heap is also live.
Have an exception handler that catches exceptions and doesn't do
anything
with the error manager stack (I.E. it doesn't call task.ErrMgr.Clear).
If the handler is activated repeatedly in the same task, the stack of
exceptions will grow until you run out of memory or the task terminates
(task termination empties the error manager stack.)
It seems to me that this is a weakness in the tool that should be addressed.
Does anyone else have any opinions on this subject?
Actually, the implementation of the advanced features supported by the Forte
product
results in some complications in areas that can be hard to explain. Memory
management
happens to be one of the areas most effected. A precise explanation to a
non-deterministic process is not possible, but the following attempts to
explain the
source of the non-determinism.
o The ability to call from compiled C++ to interpreted TOOL and back
to compiled C++.
This single ability causes most of the strange effects mentioned in
this thread.
For C++ code the location of all variables local to a method is not
know
(I.E. C++ compilers can't tell you at run-time what is a variable
and what
isn't.) We use the pessimistic assumption that anything that looks
like a
reference to a memory object is a reference to a memory object. For
interpreted
TOOL code the interpreter has exact knowledge of what is a reference
and what
isn't. But the TOOL interpreter is itself a C++ method. This means
that any
any memory objects referenced by the interpreter during the
execution of TOOL
code could be stored in local variables in the interpreter. The TOOL
interpreter
runs until the TOOL code returns or the TOOL code calls into C++.
This means
that many levels of nested TOOL code can be the source of values
assigned to
local variables in the TOOL interpreter.
This is the complicated reason that answers the question: Why doesn't a
variable that is created and only used in a TOOL method that has
returned
get freed? It is likely that the variable is referenced by local
variables
in the TOOL interpreter method. This is also why setting the
variable to NIL
before returning doesn't seem to help. If the variable in question is a
Array than invoke Clear() on the Array seems to help, because even
though the
Array is still live the objects referenced by the Array have less
references.
The other common occurrence of this effect is in a TextData that
contains a
large string. In this case, invoking SetAllocatedSize(0) can be used
to NIL
the reference to the memory object that actually holds the sequence of
characters. Compositions of Arrays and TextData's (I.E. a Array of
TextData's
that all have large TextDatas.) can lead to even more problems.
When the TOOL code is turned into a compiled partition this effect
is not
noticed because the TOOL interpreter doesn't come into play and
things execute
the way most people expect. This is one area that we try to improve
upon, but it is complicated by the 15 different platforms, and thus
C++ compilers,
that we support. Changes that work on some machines behave
differently on other
machines. At this point in time, it occasionally still requires that
a TOOL
programmer actively address problems. Obviously we try to reduce
this need over
time.
o Automatic memory management for C++ with support for multi-processor
threads.
Supporting automatic memory management for C++ is something that is
not a very
common feature. It requires a coding standard that defines what is
acceptable and
what isn't. Additionally, supporting multi-processor threads adds
its own set of
complications. Luckily TOOL users are insulated from this because
the TOOL to C++
code generator knows the coding standard. In the end you are
impacted by the C++
compiler and possibly the differences that occur between different
compilers and/or
different processors (I.E. Intel X86 versus Alpha.) We have seen
applications that
had memory utilization differences of up to 2:1.
There are two primary sources of differences.
The first source is how compilers deal with dead assignments. The
typical TOOL
fragment that is being memory manager friendly might perform the
following:
temp : SomeObject = new;
... // Use someObject
temp = NIL;
return;
When this is translated to C++ it looks very similar in that temp
will be assigned the
value NULL. Most compilers are smart enough to notice that 'temp' is
never used again
because the method is going to return immediately. So they skip
setting 'temp' to NULL.
In this case it should be harmless that the statement was ignored
(see next example for a different variation.) In more
complicated examples that involve loops (especially long
lived event loops) a missed NIL assignment can lead to leaking the
memory object whose
reference didn't get set to NIL (incidentally this is the type of
problem that causes
the TOOL interpreter to leak references.)
The second source is a complicated interaction caused by history of
method invocations.
Consider the following:
Method A() invokes method B() which invokes method C().
Method C() allocates a temporary TextData, invokes
SetAllocatedSize(1000000)
does some more work and then returns.
Method B() returns.
Method A() now invokes method D().
Method D() allocates something that cause the memory manager to look
for memory objects to free.
Now, even though we have returned out of method C() we have starting
invoking
methods. This causes us to use re-use portions of the C++ stack used to
maintain the history of method invocation and space for local variables.
There is some probability that the reference to the 'temporary' TextData
will now be visible to the memory manager because it was not overwritten
by the invocation of D() or anything invoked by method D().
This example answers questions of the form: Why does setting a local
variable to
NIL and returning and then invoking task.Part.Os.RecoverMemory not
cause the
object referenced by the local variable to be freed?
In most cases these effects cause memory utilization to be slightly
higher
than expected (in well behaved cases it's less than 5%.) This is a small
price to pay for the advantages of automatic memory management.
An object-oriented programming style supported by automatic memory
management makes it
easy to extended existing objects or sets of objects by composition.
For example:
Method A() calls method B() to get the next record from the
database. Method B()
is used because we always get records, objects, of a certain
type from
method B() so that we can reuse code.
Method A() enters each row into a hash table so that it can
implement a cache
of the last N records seen.
Method A() returns the record to its caller.
With manual memory management there would have to be some interface
that allows
Method A() and/or the caller of A() to free the record. This
requires
that the programmer have a lot more knowledge about the
various projects
and classes that make up the application. If freeing doesn'
happen you
have a memory leak, if you free something while its still
being used the
results are unpredictable and most often fatal.
With automatic memory management, method A() can 'free' its
reference by removing
the reference from the hash table. The caller can 'free' its
reference by
either setting the reference to NIL or getting another
record and referring
to the new record instead of the old record.
Unfortunately, this convenience and power doesn't come for free. Consider
the following,
which comes from the Forte' run-time system:
A Window-class object is a very complex beast. It is composed of two
primary parts:
the UserWindow object which contains the variables declared by the
user, and the
Window object which contains the object representation of the window
created in
the window workshop. The UserWindow and the Window reference each
other. The Window
references the Menu and each Widget placed on the Window directly. A
compound Window
object, like a Panel, can also have objects place in itself. These
are typically
called the children. Each of the children also has to know the
identity of it's
Mom so they refer to there parent object. It should be reasonably
obvious that
starting from any object that make up the window any other object
can be found.
This means that if the memory manager finds a reference to any
object in the Window
it can also find all other objects in the window. Now if a reference
to any object
in the Window can be found on the program stack, all objects in the
window can
also be found. Since there are so many objects and the work involved
in displaying
a window can be very complicated (I.E. the automatic geometry
management that
layouts the window when it is first opened or resized.) there are
potentially many
different reference that would cause the same problem. This leads to
a higher than
normal probability that a reference exists that can cause the whole
set of Window
objects to not be freed.
We solved this problem in the following fashion:
Added a new Method called RecycleMemory() on UserWindow.
Documented that when a window is not going to be used again
that it is
preferably that RecycleMemory() is invoked instead
of Close().
The RecycleMemory() method basically sets all references
from parent to
child to NIL and sets all references from child to
parent to NIL.
Thus all objects are isolated from other objects
that make up
the window.
Changed a few methods on UserWindow, like Open(), to check
if the caller
is trying to open a recycled window and throw an
exception.
This was feasible because the code to traverse the parent/child
relationship
ready existed and was being used at close time to perform other
bookkeeping
operations on each of the Widgets.
To summarize:
Automatic memory management is less error prone and more productive but
doesn't come totally for free.
There are things that the programmer can do that assists the memory
manager:
o Set object reference to NIL when known to be correct (this
is the
way the memory is deallocated in an automatic system.)
o Use methods like Clear() on Array and SetAllocatedSize()
on TextData to
that allow these objects to set their internal
references to NIL
when known to be correct.
o Use the RecycleMemory() method on windows, especially very
complicated
windows.
o Build similar type of methods into your own objects when
needed.
o If you build highly connected structures that are very
large in the
number of object involved think that how it might be
broken
apart gracefully (it defeats some of the purpose of
automatic
management to go to great lengths to deal with the
problem.)
o Since program stacks are the source of the 'noise'
references, try
and do things with less tasks (this was one of the
reasons that
we implemented event handlers so that a single task
can control
many different windows.)
Even after doing all this its easy to still have a problem.
Internally we have
access to special tools that can help point at the problem so that
it can be
solved. We are attempting to give users UNSUPPORTED access to these
tools for
Release 3. This should allow users to more easily diagnose problems.
It also
tends to enlighten one about how things are structured and/or point out
inconsistencies that are the source of known/unknown bugs.
Derek
Derek Frankforth [email protected]
Forte Software Inc. [email protected]
1800 Harrison St. +510.869.3407
Oakland CA, 94612I beleive he means to reformat it like a floppy disk.
Go into My Computer, Locate the drive letter associated with your iPod(normally says iPod in it, and shows under removable storage).
Right click on it and choose format - make sure to not have the "quick format" option checked. Then let it format.
If that doesnt work, There are steps somewhere in the 5th gen forum( dont have the link off hand) to try to use the usbstor.sys to update the USB drivers for the Nano/5th gen.
Maybe you are looking for
-
I am confused with the various products and their capabilities in SAP. My requirement is very simple. I need a few dashboards on a web explorer interface from my datawarehouse. These dashboards need to show data for Actual Sales against targets throu
-
I want to check XI setting in my existing sever
Hi Guru's I want to check XI setting in my existing sever , as i m new in xi. I want to know abt SLD , adaptor and alert setting etc plz help me Thanks in advance Edited by: sandeep gautam on Dec 26, 2007 7:47 AM
-
Itunes register settings missing
when itunes opens I get a message that says _The Registry settings used by itunes drivers for importing and burning cd's and dvd's are missing.This can happen as a result of installing other cd burning software. Please Reinstall itunes. The thing is
-
What' the best approach for synching a drum machine to AA3
Hi I have recently purchased both AA3 and an Alesis SR-18. I'm wondering how to go about synching the drum machine to AA3. Do I do it via SMPTE or Midi? And exactly how do I do that? Later on I will also need to link my synth via midi to the AA3 sequ
-
Chrome failing when switching users
This also happens when powering down. Chrome widows shrink and I canot open them. Cheers SteveW