Fwd: Presentation syntax writer

I copied this surface model from Evren's website pointer below.

>Date: Thu, 12 Jan 2006 01:13:29 -0500
>From: Evren Sirin <evren@cs.umd.edu>
>
>I got hold of the program that generates the presentation syntax output
>from RDF/XML and put it on the Web for everybody to use. The page to run
>the programs is here:
>http://www.mindswap.org/2004/owl-s/pres_syntax/
>
>If you click the example links on the page you can directly get the Congo
>and BravoAir process models translated to presentation syntax. The program
>only supports OWL-S 1.2 so it won't work for earlier versions. And it does
>not yet print the ResultVar's but I think it is complete for the rest of
>the constructs.
>
>BTW, the program reports a warning message about Congo 1.2 where
>rdf:ID="#LocateBook_aBook" should be changed to rdf:ID="LocateBook_aBook".
>Also there are some expressions that needs to be fixed, e.g. rdf:type is
>used in swrl:IndividualPropertyAtom but the correct way should be
>swrl:ClassAtom.
>
>Regards,
>Evren
>--
>[To unsubscribe to this list send an email to "majdart@bbn.com"
>with the following text in the BODY of the message "unsubscribe daml-process"]

with_namespaces
   (uri"http://www.daml.org/services/owl-s/1.2/CongoProcess.owl#",
    profileHierarchy:
"http://www.daml.org/services/owl-s/1.2/ProfileHierarchy.owl#",
    xsd: "http://www.w3.org/2001/XMLSchema#",
    owl-s: "http://www.daml.org/services/owl-s/1.2/",
    rdfs: "http://www.w3.org/2000/01/rdf-schema#",
    time-entry: "http://www.isi.edu/~pan/damltime/time-entry.owl#",
    rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
    owl: "http://www.w3.org/2002/07/owl#")
{

    define atomic process LoadUserProfile()

    define atomic process FinalizeBuy()

    define atomic process PutInCart(
       inputs: (PutInCartBookISBN - profileHierarchy:ISBN))

    define atomic process SignIn(
       inputs: (SignInInfo - SignInData))

    define atomic process SpecifyPaymentMethod(
       inputs: (SpecifyPaymentMethodCreditCardExpirationDate -
time-entry:Instant
                SpecifyPaymentMethodCreditCardType - CreditCardType
                SpecifyPaymentMethodCreditCardNumber - xsd:decimal))

    define atomic process ExpressCongoBuy(
       inputs: (ExpressCongoBuySignInInfo - SignInData
                ExpressCongoBuyBookISBN - profileHierarchy:ISBN
                ExpressCongoBuyCreditCardNumber - xsd:decimal
                ExpressCongoBuyCreditCardExpirationDate - xsd:gYearMonth
                ExpressCongoBuyCreditCardType - CreditCardType),
       locals: (ExpressCongoBuyAcctID - AcctID
                ExpressCongoBuyCreditCard - CreditCard),
       outputs: (ExpressCongoBuyOutput - ExpressCongoBuyOutputType),
       precondition: (hasAcctID(ExpressCongoBuySignInInfo,
ExpressCongoBuyAcctID),
       precondition: (cardNumber(ExpressCongoBuyCreditCard,
ExpressCongoBuyCreditCardNumber) &
                      validity(ExpressCongoBuyCreditCard, Valid),
       result: (<< Anonymous Class >>(ExpressCongoBuyBookISBN)
                |->
                (ExpressCongoBuyOutput = NotifyBookOutOfStock)),
       result: (forall (ExpressCongoBuyBook - profileHierarchy:Book
                        ExpressCongoBuyShipment - Shipment)
                profileHierarchy:hasISBN(ExpressCongoBuyBook,
ExpressCongoBuyBookISBN) &
                InStockBook(ExpressCongoBuyBook)
                |->
                Shipment(ExpressCongoBuyShipment) &
                shippedTo(ExpressCongoBuyShipment, ExpressCongoBuyAcctID) &
                shippedBook(ExpressCongoBuyShipment, ExpressCongoBuyBook)))

    define atomic process CreateAcct(
       inputs: (CreateAcctInfo - AcctInfo),
       outputs: (CreateAcctOutput - AcctID))

    define atomic process LocateBook(
       inputs: (LocateBookBookName - xsd:string),
       outputs: (LocateBookOutput - LocateBookOutputType),
       result: (profileHierarchy:title(LocateBook_aBook, LocateBookBookName) &
                OutOfStockBook(LocateBook_aBook)
                |->
                (LocateBookOutput = NotifyBookOutOfStock)),
       result: (forall (LocatedBook - profileHierarchy:Book)
                profileHierarchy:title(LocatedBook, LocateBookBookName) &
                InStockBook(LocatedBook)
                |->
                profileHierarchy:ISBN(LocateBookOutput)))

    define atomic process SpecifyDeliveryDetails(
       inputs: (DeliveryAddress - xsd:string
                PackagingSelection - PackagingType
                DeliveryTypeSelection - DeliveryType))

    define composite process SignInAlternatives(
       inputs: (SignInAlternativesCreateAcctInfo - AcctInfo
                SignInAlternativesSignInData - SignInData),
       outputs: (SignInAlternativesAcctID - AcctID),
       result: (NonExistingAcct(SignInAlternativesSignInData)
                |->
                output(SignInAlternativesAcctID <=
CreateAcctSequencePerform.CreateAcctSequenceCreateAcctOutput)),
       result: (hasAcctID(SignInAlternativesSignInData,
SignInAlternativesAcctID)
                |->
                output(SignInAlternativesAcctID <=
SignInSequencePerform.SignInSequenceAcctID)))
    {
       CreateAcctSequencePerform :: perform
CreateAcctSequence(CreateAcctSequenceCreateAcctInfo <=
SignInAlternativesCreateAcctInfo);?
       SignInSequencePerform :: perform
SignInSequence(SignInSequenceSignInInfo <= SignInAlternativesSignInData)
    }

    define composite process CreateAcctSequence(
       inputs: (CreateAcctSequenceCreateAcctInfo - AcctInfo),
       outputs: (CreateAcctSequenceCreateAcctOutput - AcctID),
       result: (output(CreateAcctSequenceCreateAcctOutput <=
CreateAcctPerform.CreateAcctOutput)))
    {
       CreateAcctPerform :: perform CreateAcct(CreateAcctInfo <=
CreateAcctSequenceCreateAcctInfo);
       LoadUserProfilePerform1 :: perform LoadUserProfile()
    }

    define composite process SignInSequence(
       inputs: (SignInSequenceSignInInfo - SignInData),
       outputs: (SignInSequenceAcctID - AcctID))
    {
       SignInPerform :: perform SignIn(SignInInfo <= SignInSequenceSignInInfo);
       LoadUserProfilePerform :: perform LoadUserProfile()
    }

    define composite process FullCongoBuy(
       inputs: (FullCongoBuySignInData - SignInData
                FullCongoBuyDeliveryTypeSelection - DeliveryType
                FullCongoBuyCreditCardNumber - xsd:decimal
                FullCongoBuyPackagingSelection - xsd:string
                FullCongoBuyCreateAcctInfo - AcctInfo
                FullCongoBuyBookName - xsd:string
                FullCongoBuyCreditCardExpirationDate - xsd:gYearMonth
                FullCongoBuyCreditCardType - CreditCardType
                FullCongoBuyDeliveryAddress - xsd:string),
       outputs: (FullCongoBuyOutput -
owl-s:CongoProcess.owlFullCongoBuyOutputType
                 FullCongoBuyCreateAcctOutput - AcctID),
       result: (profileHierarchy:title(aBook, FullCongoBuyBookName) &
                OutOfStockBook(aBook)
                |->
                output(FullCongoBuyOutput <=
LocateBookPerform.LocateBookOutput)),
       result: (forall (FullCongoBuyShipment - Shipment)
                profileHierarchy:title(aBook, FullCongoBuyBookName) &
                InStockBook(aBook)
                |->
                output(FullCongoBuyCreateAcctOutput <=
CongoBuyBookPerform.CongoBuyBookCreateAcctOutput) &
                Shipment(FullCongoBuyShipment)))
    {
       LocateBookPerform :: perform LocateBook(LocateBookBookName <=
FullCongoBuyBookName);
       if( profileHierarchy:title(aBook, FullCongoBuyBookName) &
           InStockBook(aBook) )
       then
       {
          CongoBuyBookPerform :: perform
CongoBuyBook(CongoBuyBookSignInData <= FullCongoBuySignInData,
                                                      CongoBuyBookPackagingSelection
<= FullCongoBuyPackagingSelection,
                                                      CongoBuyBookDeliveryTypeSelection
<= FullCongoBuyDeliveryTypeSelection,
                                                      CongoBuyBookCreditCardNumber
<= FullCongoBuyCreditCardNumber,
                                                      CongoBuyBookISBN <=
LocateBookPerform.LocateBookOutput,
                                                      CongoBuyBookCreditCardExpirationDate
<= FullCongoBuyCreditCardExpirationDate,
                                                      CongoBuyBookCreditCardType
<= FullCongoBuyCreditCardType,
                                                      CongoBuyBookDeliveryAddress
<= FullCongoBuyDeliveryAddress,
                                                      CongoBuyBookCreateAcctInfo
<= FullCongoBuyCreateAcctInfo)
       }
    }

    define composite process CongoBuyBook(
       inputs: (CongoBuyBookDeliveryTypeSelection - DeliveryType
                CongoBuyBookDeliveryAddress - xsd:string
                CongoBuyBookPackagingSelection - PackagingType
                CongoBuyBookCreditCardExpirationDate - time-entry:Instant
                CongoBuyBookCreateAcctInfo - AcctInfo
                CongoBuyBookISBN - profileHierarchy:ISBN
                CongoBuyBookCreditCardNumber - xsd:string
                CongoBuyBookSignInData - SignInData
                CongoBuyBookCreditCardType - CreditCardType),
       outputs: (CongoBuyBookCreateAcctOutput - AcctID),
       result: (output(CongoBuyBookCreateAcctOutput <=
BuySequencePerform.BuySequenceAcctID)))
    {
       BuySequencePerform :: perform
BuySequence(BuySequenceCreditCardExpirationDate <=
CongoBuyBookCreditCardExpirationDate,
                                                 BuySequenceCreateAcctInfo
<= CongoBuyBookCreateAcctInfo,
                                                 BuySequenceSignInData <=
CongoBuyBookSignInData,
                                                 BuySequenceCreditCardNumber
<= CongoBuyBookCreditCardNumber,
                                                 BuySequenceCreditCardType
<= CongoBuyBookCreditCardType,
                                                 BuySequenceBookISBN <=
CongoBuyBookISBN);
       SpecifyDeliveryDetailsPerform :: perform
SpecifyDeliveryDetails(PackagingSelection <= CongoBuyBookPackagingSelection,
                                                                       DeliveryTypeSelection
<= CongoBuyBookDeliveryTypeSelection,
                                                                       DeliveryAddress
<= CongoBuyBookDeliveryAddress);
       FinalizeBuyPerform :: perform FinalizeBuy()
    }

    define composite process BuySequence(
       inputs: (BuySequenceCreditCardNumber - xsd:decimal
                BuySequenceCreditCardExpirationDate - time-entry:Instant
                BuySequenceSignInData - SignInData
                BuySequenceCreateAcctInfo - AcctInfo
                BuySequenceBookISBN - profileHierarchy:ISBN
                BuySequenceCreditCardType - CreditCardType),
       outputs: (BuySequenceAcctID - AcctID),
       result: (output(BuySequenceAcctID <=
SignInAlternativesPerform.SignInAlternativesAcctID)))
    {
       PutInCartPerform :: perform PutInCart(PutInCartBookISBN <=
BuySequenceBookISBN);
       SignInAlternativesPerform :: perform
SignInAlternatives(SignInAlternativesSignInData <= BuySequenceSignInData,
                                                               SignInAlternativesCreateAcctInfo
<= BuySequenceCreateAcctInfo);
       SpecifyPaymentMethodPerform :: perform
SpecifyPaymentMethod(SpecifyPaymentMethodCreditCardExpirationDate <=
BuySequenceCreditCardExpirationDate,
                                                                   SpecifyPaymentMethodCreditCardType
<= BuySequenceCreditCardType,
                                                                   SpecifyPaymentMethodCreditCardNumber
<= BuySequenceCreditCardNumber)
    }

}

--
[To unsubscribe to this list send an email to "majdart@bbn.com"
with the following text in the BODY of the message "unsubscribe daml-process"]