\n
- Introduction<\/A>
\n- Objective and Target User<\/A><\/LI>
\n\t- How this works<\/A><\/LI>
\n\t- Prerequisites<\/A><\/LI>
\n<\/OL>
\n<\/LI>
\n\t- Preparation<\/A>
\n- Download the MS Word Importer extension<\/A><\/LI>
\n\t- Install Java on the machine that runs Importer<\/A><\/LI>
\n\t- Prepare the document for import<\/A><\/LI>
\n<\/OL>
\n<\/LI>
\n\t- Import the document to Polarion <\/A>
\n- Prepare mapping for Polarion<\/A><\/LI>
\n\t- Adjusting styles<\/A><\/LI>
\n\t- Simulate import, to make sure the mapping is correct<\/A><\/LI>
\n<\/OL>
\n<\/LI>
\n\t- Import content of the document into Polarion <\/A>
\n- Create a project<\/A><\/LI>
\n\t- Create a Module as import target<\/A><\/LI>
\n\t- Run the importer<\/A><\/LI>
\n<\/OL>
\n<\/LI>
\n\t- Tips and Best Practices<\/A><\/LI>
\n<\/OL>
\n<\/DIV>
\nBy Nick Entin<\/EM>
\n1 Introduction<\/H2>
\n1.1 Objective and Target User<\/H3>
\nThe MS Office Word Importer for Polarion<\/STRONG> (\u201cImporter<\/EM>\u201d ) migrates existing Requirements or other types of work items, described in a MS Word document format to Polarion. The Importer is targeted at Administrators, Business Analysts, and Requirements Engineers with Polarion user training as a pre-requisite.<\/p>\nThe Importer allows requirements data currently in MS Office Word format to be imported into Polarion for reuse without needing to recreate them in the Polarion portal. The Importer follows these basic process steps:
\n- Recognizes MS Word document parts representing the work items (i.e. Requirements), and associated attributes such as descriptions, content, graphics, etc. to be imported.<\/LI>
\n\t - Establishes the mapping properties of the MS Word document artifact data to be imported to Polarion, mapping properties of the artifact to the Polarion model – e.g. setting the title of the work item, description and other attributes.<\/LI>
\n\t - Enables recognition of the MS Word document structure and reproduction of the same hierarchy in Polarion.<\/LI>
\n<\/OL>
\n1.2 How this works<\/H3>
\nThe principle of the Importer is relatively simple \u2013 each paragraph in the document represents potential work item or its attribute. Styles, applied to the paragraphs, allow recognition and mapping to the desired model.<\/p>\nThis way, heading-formatted paragraphs could be mapped to titles of corresponding work items, and all text in between should go to description. Heading levels describe the parent-child relationship of the data objects. For instance, Heading 2<\/EM>-formatted text may be mapped to a child work item of the corresponding Heading 1<\/EM>.<\/p>\n
It is also possible that style-highlighted parts of the text will be mapped to attributes of work item. For example, the name of a person is highlighted as \u201cAuthor\u201d style in document, and the name will be used as assignee of the work item during the import.<\/p>\n
Naturally, every author likes to format his\/her document with nice styling, applying company-branding and so forth. Therefore, before the Importer can process a document, it should be taught the applied styles and their semantics.<\/p>\n
Importer is a Java application, connecting over Web Services to Polarion server. This means that the application will connect via HTTP\/HTTPS protocol to the server, so the user must have a LAN\/Internet connection to Polarion server during entire import, and must also have a user account in Polarion and be able to supply a valid user ID and password.<\/p>\n
Parsing capabilities of the Importer are based on the open source project Apache POI<\/EM> (http:\/\/poi.apache.org\/<\/A>), and is itself an open source project. More details as well as link to the sources may be found here:
\n- http:\/\/extensions.polarion.com\/polarion\/extensions\/extension.jsp?extension=PE-2<\/A><\/LI>
\n\t- http:\/\/community.polarion.org\/polarion\/#\/project\/Word\/home<\/A><\/LI>
\n\t- http:\/\/community.polarion.org\/polarion\/#\/project\/Word\/repository\/browser<\/A> (you have to be a registered Polarion user to authenticate \u2013 please follow the previous link and register yourself if you don\u2019t have credentials yet.)<\/LI>
\n<\/UL>
\n1.3 Prerequisites<\/H3>
\nThe Importer can import binary documents, saved in MS Word 97-2003 format. If you use later versions of MS Office, you should use Save as > Word 97-2003 Document<\/STRONG> to convert it to an importable format.<\/p>\nThe user who is going to import document should have an active account in Polarion an be able to supply a valid user name and password. Also, the account should be associated with a Polarion Requirements or Polarion ALM license.<\/p>\n
As Importer runs as a batch application, the user should be have the necessary permissions to call programs from command line, and be able to create and update configuration files in a simple text editor such as Windows Notepad.<\/p>\n
\n2. Preparation<\/H2>
\n2.1 Download the MS Word Importer extension<\/H3>
\nThe importer is available at http:\/\/extensions.polarion.com\/polarion\/extensions\/extension.jsp?extension=PE-2<\/A><\/p>\nDownload it and extract e.g. to C:WordImporter<\/STRONG> (referred as from now on as \u201cimporter folder\u201d).
\n2.2 Install Java on the machine that runs Importer<\/H3>
\nImporter requires the Java Runtime Environment (install Java 5 or newer).
\n2.3 Prepare the document for import<\/H3>
\nAs mentioned before, you need to be sure it\u2019s saved in Word 97-2003-compatible format. Run Save as\u2026\/Word 97-2003 Document<\/STRONG> if you\u2019re using MS Office 2007 or a later edition.<\/p>\nThis way the file extension will be .DOC, not <\/EM>.DOCX.<\/p>\n
Copy the .doc file into the importer folder. For simplicity we\u2019ll refer to the document as \u201cinput.doc\u201d in the following steps. You may use even the document you are now reading as trial for your import \ud83d\ude42
\n3 Import the document to Polarion<\/H2>
\n3.1 Prepare mapping for Polarion<\/H3>
\nPolarion should recognize structure of the document and be able to find our separate artifacts there (e.g. to find what constitutes a work item, the work item hierarchy, etc.). The Importer uses style tagging for mapping such entities.<\/p>\nFor example: we may specify that every text styled as Heading 1 is the beginning of work item (so the heading text should go to the Title field of the work item), and text between this heading and the next one will be the work item. Description. If any text styled as Heading 2 is encountered after a Headin1, it should be interpreted as another work item with a child-relationship to the previous Headin1.<\/p>\n
Importer supports extraction of Styles used, thus simplifying mapping.<\/p>\n
Let\u2019s execute the following command in the importer folder (prerequisite \u2013 actions from paragraphs 2.1, 2.2 and 2.3 are executed):
\nJava \u2013jar WordImporter.jar input.doc input.doc.map \u2013list<\/STRONG><\/PRE>
\nAs result you should get new file \u201cinput.doc.map\u201d in addition to your original document.<\/p>\nFor convenience, the generated .map file includes comments, explaining how to configure mapping, the possible options, etc. This text is, of course, static. However at the end of the file there are generated statements, which are specific for your concrete document:
\n#Styles in file input.doc#style1=Heading 1
\n#style2=List Paragraph
\n#style3=Normal
\n#style4=Heading 2
\n#style5=TOC 1
\n#style6=TOC 2
\n#style7=TOC Heading
\n#style8=Title<\/PRE>
\nThe entries are commented, because now those styles can be reused in a \u201cH<x>\u201d section (mapping to the Headings) and in an \u201cignore\u201d section (meaning to completely skip during the import).
\n3.2 Adjusting styles<\/H3>
\nLet\u2019s open the .map file. Scroll till the end and check generated entries there.<\/p>\nThe importer generates this default mapping\u2026
\nignore=TOC 1,TOC 2,TOC 3,Header,Footer,Copyright
\nH1=Heading 1
\nH2=Heading 2
\nH3=Heading 3
\nH4=Heading 4
\nH5=Heading 5
\nH6=Heading 6
\nH7=Heading 7
\nH8=Heading 8
\nH9=Heading 9<\/PRE>
\n\u2026which says following: All paragraphs, starting with \u201cHeading 1\u201d formatted title will be recognized as top-level elements, \u201cHeading 2\u201d will be recognized as subitems of \u201cHeading 1\u201d, etc.<\/p>\nThere might be some cosmetic texts in the document, which should be ignored by the importer: for example, page headers and footers should not be interpreted, and they should simply be skipped by the processor. Those styles are listed in the \u2018ignore\u2019 section.<\/p>\n
Please note that if you don\u2019t list Header or Footer in the \u2018ignore\u2019 section, there is a danger that texts of headers\/footers will repeat in every work item description that crosses the page border. As mentioned above, text between headings would be mapped to work item descriptions, and headers and footers between pages are also processed as paragraphs.<\/p>\n
Those entries are just by way of example. You need to find what\u2019s actually present in the document you intend to import. All styles used in the document are listed in the commented section at the end of the file:
\n#Styles in file input.doc#style1=Heading 1<\/SPAN>
\n#style2=List Paragraph
\n#style3=Normal
\n#style4=Heading 2
\n#style5=TOC 1
\n#style6=TOC 2
\n#style7=TOC Heading
\n#style8=Title<\/PRE>
\nFor our relatively simple document, we\u2019ll create requirement type work items out of the styles Heading 1 and Heading 2:
\nH1=Heading 1
\nH2=Heading 2<\/PRE>
\nThe example document was saved from Word 2007 and there are two additional styles: \u201cTOC Heading\u201d and \u201cTitle\u201d, which are non-relevant for the data to be imported, so let\u2019s put these to the mapping:
\nignore=TOC 1,TOC 2,TOC 3,Header,Footer,Copyright,TOC Heading,Title<\/STRONG><\/PRE>
\nAs the result, the mapping file may look as following:<\/p>\n![\"\"](\"http:\/\/community.plm.automation.siemens.com\/legacyfs\/online\/siemensplm_blogs\/2010\/04\/screen12.png\" "\\"screen1\\"")
<\/A>
\n3.3 Simulate import, to make sure the mapping is correct.<\/H3>
\nLet\u2019s try out import using the mapping file.<\/p>\nRun following command line:
\njava -jar WordImporter.jar “input.doc” “input.doc.map” \u2013simulate<\/STRONG><\/PRE>
\nAs result you should see simulate.html generated in your working directory. Open it in your browser and see if recognition of your items is correct.
\n4 Import content of the document into Polarion<\/H2>
\n4.1 Create a project<\/H3>
\nLog in to Polarion using a repository-level Administrator account and a create new project.<\/p>\nRemember the project ID and make sure that the \u201crequirement\u201d work item type is defined in the project. (You may import some other type of work item already defined in the project, but please specify the type ID in the command line parameter of the importer when starting it. More on this paramter lster in this document.)<\/p>\n
You may want to consider creating and using a test project as the target for the first import run. This would allow you to repeat the import in case of any issues without disturbing your production project flow.<\/p>\n
Start a new project as shown:<\/p>\n
![\"\"](\"http:\/\/community.plm.automation.siemens.com\/legacyfs\/online\/siemensplm_blogs\/2010\/04\/screen2.png\" "\\"screen2\\"")
<\/A><\/p>\n(Remember that you must have Administrator permissions for the repository or the project group in which the new project will be created.)<\/p>\n
Please specify the location and ID of the project (e.g. \u201cSandbox\/WordImport\u201d as location in the repository and \u201cWordImport\u201d as project ID:<\/p>\n
![\"\"](\"http:\/\/community.plm.automation.siemens.com\/legacyfs\/online\/siemensplm_blogs\/2010\/04\/screen3.png\" "\\"screen3\\"")
<\/A><\/p>\nSelection of the Project Template is not especially important. Just choose a default one for the Polarion product you are using (Polarion ALM or Polarion Requirements):<\/p>\n
![\"\"](\"http:\/\/community.plm.automation.siemens.com\/legacyfs\/online\/siemensplm_blogs\/2010\/04\/screen4.png\" "\\"screen4\\"")
<\/A><\/p>\nNOTE: The above figure shows the default template selection in Polarion ALM.<\/p>\n
Now let\u2019s follow the wizard. Click Next<\/STRONG> to create the project after reviewing the Summary, and confirming project creation. Now we may want to redefine default Tracker Prefix (i.e. the prefix of each work item created in the project) \u2013 to make it unique, e.g. \u201cWORD\u201d:<\/p>\n
![\"\"](\"http:\/\/community.plm.automation.siemens.com\/legacyfs\/online\/siemensplm_blogs\/2010\/04\/screen5.png\" "\\"screen5\\"")
<\/A><\/p>\nTIP:<\/STRONG> Unique tracker prefix is important when there is the possibility of repository commits using external version control clients. If a work item ID is cited in a commit message, the commit is linked to the cited item. If the prefix is not unique, the commite could get linked to the wrong item in the wrong project, messing up your traceablity.
\n4.2 Create a Module as import target<\/H3>
\nWe\u2019ll demonstrate a more complex approach and import the document into a Module, a special container for structured sets of work items, which can later be used for versioning, inheritance or other operations on a group of work items. A Module merges the worlds of document-centric information and data-centric information.<\/p>\nModules ensure that the structure of the work items they contain, and the way they are sorted, remains intact at all times. Therefore after import we should be able to recognize original structure of the document.<\/p>\n
Let\u2019s create a new module, give it a name, and enable Outline numbering without prefix:<\/p>\n
![\"\"](\"http:\/\/community.plm.automation.siemens.com\/legacyfs\/online\/siemensplm_blogs\/2010\/04\/screen6.png\" "\\"screen6\\"")
<\/A><\/p>\nAfter confirmation, you\u2019ll be forwarded to the Home page of the new module, but there are no work items yet, so nothing interesting so far:<\/p>\n
![\"\"](\"http:\/\/community.plm.automation.siemens.com\/legacyfs\/online\/siemensplm_blogs\/2010\/04\/screen7.png\" "\\"screen7\\"")
<\/A>
\n4.3 Run the importer<\/H3>
\nThere are several additional options, you may consider before proceeding with the following steps:
\n- Possibility to create document root (i.e. a work item, which represents the imported document itself, thus content of the document will be linked below it in the structure)<\/LI>
\n<\/UL>
\n- Possibility to import work items into a Module<\/LI>
\n\t - If you do not import into a module, what parent-child relationship you want to use (i.e. what link role to apply)<\/LI>
\n<\/UL>
\nThose three parameters might be added to the command line. We\u2019ll use the command line option to import into a Module and will not use the document root \u2013 this way we will get the same outline numbering as in the original Word Document.<\/p>\nExecute command line:
\njava -jar WordImporter.jar “input.doc” “input.doc.map” “http:\/\/admin:admin@localhost:81\/polarion\/ws\/services\/” WordImport requirement -module:”First Requirements”<\/STRONG><\/PRE>
\nNote: requirement<\/STRONG> in the command line refers to default type of work item to be used. This is a mandatory property of each work item, therefore a default has to be provided in the arguments.<\/p>\nPlease check the URL and credentials for the Polarion server. In this example \u201clocalhost:81\u201d is used to access Polarion server. Please replace it with the actual URL of your server. Also replace admin:admin<\/STRONG> with the username\/password of the Administrator user, and specify the port number.<\/p>\n
You\u2019ll see messages about creation of particular work items in the console Window, similar to:
\nINFO – Started processing root context.
\nINFO – Skipping empty heading.
\nINFO – Finished processing root context
\nINFO – Started processing Workitem.
\nINFO – Updated Workitem WORD-1
\nINFO – Started processing Workitem.
\nINFO – Updated Workitem WORD-2<\/PRE>
\nHow many times one work item might be updated depends on the number of attributes, so don\u2019t be worried when the same work item is updated several times.<\/p>\nDuring WebService application, especially one sending a large amount of data, the server may refuse to confirm a commit immediately. WebService repeats requests until \u201cok\u201d or \u201crollback\u201d response is received. Therefore, don\u2019t worry when messages like these appear in the console:
\nINFO – Committing changes…
\nINFO – I\/O exception (org.apache.commons.httpclient.NoHttpResponseException) caught when processing request: The server localhost failed to respond
\n<\/STRONG>INFO – Retrying request
\nINFO – Commit finished.<\/PRE>
\nThese are not error messages, they are just info for the user that the operation is not yet confirmed by the server.<\/p>\nNow, when the Import is finished, you may return to the Polarion web portal and see the results:<\/p>\n
![\"\"](\"http:\/\/community.plm.automation.siemens.com\/legacyfs\/online\/siemensplm_blogs\/2010\/04\/screen8.png\" "\\"screen8\\"")
<\/A><\/p>\nCompare to the original Document:<\/p>\n
![\"\"](\"http:\/\/community.plm.automation.siemens.com\/legacyfs\/online\/siemensplm_blogs\/2010\/04\/screen9.png\" "\\"screen9\\"")
<\/A><\/p>\nIf you switch to the Table view and set the Module view mode, you\u2019ll find quick navigation just like a Table of Contents:<\/p>\n
![\"\"](\"http:\/\/community.plm.automation.siemens.com\/legacyfs\/online\/siemensplm_blogs\/2010\/04\/screen10.png\" "\\"screen10\\"")
<\/A><\/p>\nCompare to the Word document:<\/p>\n
![\"\"](\"http:\/\/community.plm.automation.siemens.com\/legacyfs\/online\/siemensplm_blogs\/2010\/04\/screen111.png\" "\\"screen11\\"")
<\/A><\/p>\nAnd one last screenshot on the imported content to demonstrate that the pictures are also imported along with text:<\/p>\n
![\"\"](\"http:\/\/community.plm.automation.siemens.com\/legacyfs\/online\/siemensplm_blogs\/2010\/04\/screen121.png\" "\\"screen12\\"")
<\/A>
\n5. Tips and Best Practices<\/H2>
\nUse the importer prior to create Live Doc documents \u2026<\/EM><\/p>\nIf you think you will want to work further in MS Office Word with the items from your original document, still having full Web UI access to the items through the Polarion portal, you may follow this process:
\n- Import the legacy document using Importer.<\/LI>
\n\t - Export from Polarion to a LiveDoc document (thereby converting storage to Word persistency)<\/LI>
\n\t - Continue to work with the data via the Polarion portal, or using Office 2003 Professional+ (LiveDocs are stored as XML files, which are supported only by MS Office 2003 Professional or more recent releases of MS Office).<\/LI>
\n<\/UL>
\nUse the importer to ramp up quickly via reuse of legacy documents\u2026<\/EM><\/p>\nYou can consider using the Importer to get old data into Polarion quickly. For example, you might write batch file that processes each document in a folder (e.g.
\nfor %%i in (“*.*”) do run.bat %%i<\/STRONG><\/PRE>
\n <\/p>\nDo not use importer as a frequent tool. If you need to maintain MS Word use LiveDoc documents…<\/EM><\/p>\n
The Importer does not update<\/EM> any information in Polarion \u2013 it just imports information and creates NEW work items. If you need to continue to work with the work items in a MS Office application consider using LiveDoc documents.<\/p>\n
Limit importer use to trained persons\u2026<\/EM><\/p>\n
The Importer supposes that the user knows some internal details of Polarion (e.g. Project ID, IDs of the custom fields, definition of the work item hierarchy, etc.). Also, the user should have sufficient permissions to import data. Please remember that deletion of created items is not supported \u2013 one can mark them as obsolete, or even delete them from Subversion, but there is no permanent deletion in Subversion).<\/p>\n
Import to a Polarion sandbox project, verify integrity, then transfer to a Polarion project\u2026<\/EM><\/p>\n
Related to the previous, to make sure that the importer works exactly as expected, it makes sense to try first with test project or module and only then import into the production environment.<\/p>\n
Standardize MS Word document format to leverage common mapping properties\u2026<\/EM><\/p>\n
The more straightforward the formatting of the source documents, the easier imports will be in the future. If several documents have similar formatting, application of the importer will be matter of seconds, and could be even automated.<\/p>\n
When importing MS word embedded graphics \u2026<\/EM><\/p>\n
The graphics will be transferred to standalone files and referred as images from the work item description and\/or custom fields. However if you have embedded OLE objects, those are not supported by browsers and will be replaced by placeholders. Importer doesn\u2019t really care about the type of the embedded image \u2013 if your browser supports the type, you\u2019ll see the image in the GUI, if not \u2013 just a placeholder.<\/p>\n
When importing MS Word tables, or spreadsheets, \u2026.<\/EM><\/p>\n
Importer converts Word formatting to HTML, so there might be some lost of information on transferring tables \u2013row or column spans, for example.<\/p>\n
Switch off notifications during the import\u2026<\/EM><\/p>\n
Importer creates work items in the system. Depending on the notification and autoassignment configurations, your users might be notified about the creation of the work items. Import could potentially cause quite a lot of emails to be sent out if there are many items, or if your configuration notified many people about new item. You might consider temporarily disabling notifications in your Polarion configuration before running Importer.<\/p>\n
<\/p>\n![\"Nick](\"http:\/\/www.polarion.com\/img\/team_Nikolay_Entin.jpg\")
\nEditor’s Note: <\/EM>
\nThis how-to was written by Nick Entin, VP for Research & Development at Polarion Software. Nick oversees the development of all Polarion requirements management, application lifecycle management, and team collaboration software products. He is a member of the Scrum Alliance<\/A> and a Certified ScrumMaster<\/A>. You can read his profile at http:\/\/www.polarion.com\/company\/people\/index.php<\/A>.<\/p>\n","protected":false},"excerpt":{"rendered":"Introduction<\/p>\n
\t Objective and Target User
\n\t How this works
\n\t Prerequisites <\/p>\n\t Preparation<\/p>\n
\t Download the MS Word Importer extension
\n\t Install Java on the machine that runs Importer
\n\t Prepa…<\/p>\n","protected":false},"author":68980,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"spanish_translation":"","french_translation":"","german_translation":"","italian_translation":"","polish_translation":"","japanese_translation":"","chinese_translation":"","footnotes":""},"categories":[1],"tags":[],"industry":[],"product":[],"coauthors":[],"class_list":["post-856","post","type-post","status-publish","format-standard","hentry","category-news"],"_links":{"self":[{"href":"https:\/\/blogs.sw.siemens.com\/polarion\/wp-json\/wp\/v2\/posts\/856","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blogs.sw.siemens.com\/polarion\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blogs.sw.siemens.com\/polarion\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blogs.sw.siemens.com\/polarion\/wp-json\/wp\/v2\/users\/68980"}],"replies":[{"embeddable":true,"href":"https:\/\/blogs.sw.siemens.com\/polarion\/wp-json\/wp\/v2\/comments?post=856"}],"version-history":[{"count":1,"href":"https:\/\/blogs.sw.siemens.com\/polarion\/wp-json\/wp\/v2\/posts\/856\/revisions"}],"predecessor-version":[{"id":857,"href":"https:\/\/blogs.sw.siemens.com\/polarion\/wp-json\/wp\/v2\/posts\/856\/revisions\/857"}],"wp:attachment":[{"href":"https:\/\/blogs.sw.siemens.com\/polarion\/wp-json\/wp\/v2\/media?parent=856"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blogs.sw.siemens.com\/polarion\/wp-json\/wp\/v2\/categories?post=856"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blogs.sw.siemens.com\/polarion\/wp-json\/wp\/v2\/tags?post=856"},{"taxonomy":"industry","embeddable":true,"href":"https:\/\/blogs.sw.siemens.com\/polarion\/wp-json\/wp\/v2\/industry?post=856"},{"taxonomy":"product","embeddable":true,"href":"https:\/\/blogs.sw.siemens.com\/polarion\/wp-json\/wp\/v2\/product?post=856"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/blogs.sw.siemens.com\/polarion\/wp-json\/wp\/v2\/coauthors?post=856"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
\n\t - Import the legacy document using Importer.<\/LI>
\n\t - Possibility to import work items into a Module<\/LI>
\n\t - http:\/\/community.polarion.org\/polarion\/#\/project\/Word\/home<\/A><\/LI>
\n\t - http:\/\/extensions.polarion.com\/polarion\/extensions\/extension.jsp?extension=PE-2<\/A><\/LI>
\n\t - Create a Module as import target<\/A><\/LI>
\n\t - Adjusting styles<\/A><\/LI>
\n\t - Install Java on the machine that runs Importer<\/A><\/LI>
\n\t - How this works<\/A><\/LI>
\n\t - Objective and Target User<\/A><\/LI>
\n\t