Appian Sites

Sites is one of the Basic User interface. Sites allow the Designers to configure the specific tabs of tempo like Records, Reports , Actions and interfaces. 

In this ways the users who need to access only one tab can be provided security for that tab for  corresponding Group ,so that can work on it and complete their job. 

Unlike Tempo, when we want to display only set of tabs (Records, Reports, Actions and interfaces) in Appian We can go for sites.

We can set the visibility for the each tab in Sites to set of User groups. Each tab we use to call as a page and in each page we can display Record Type or Report or Action. 

Maximum 10 pages are allowed in Sites. (From Version 23.2)

We can configure Record, Reports , Actions and interfaces. Records means a Record list for particular Record type. Suppose the organization has many record types displayed in Records tab and we can configure particular record type to display. E.g. Patients, Doctors etc

Custom Data type (CDT) :-

CDT's are kind of representation of table structure.

Application Designers can create or import their own custom data types (CDTs). CDTs organize data into a structure that represents a logical grouping of related data, such as Doctor and Patient.

Careful attention must be paid to data types when passing the values from one variable to another (also called mapping data).

These variables can be mapped into process variables, enabling Process Modelers to access the variables in other nodes within the process model and pass the data to other processes and sub-processes.

Data types also apply to rule inputs and constants, but data from a node input or a process variable cannot be mapped to a rule input or a constant.

#) We can create CDT in 4 types/ways. 

1.Create from scratch 

2.Duplicate existing CDT

3.create from data base table or view  (Best way)

4.Import XSD (XML Schema Definition)

Example: Employee structure is a CDT, and the best is XML Schema Definition (XSD), using this we can create /update CDT in Appian.

#) Difference between nested CDT & flat CDT  ? explain with example.

Creating CDT with in a CDT is called Nested CDT.

Flat CDT will contain Primitive data type.

#) Few annotations we can use in XSD :

@ID to Primary key    

@Generated Value  to Auto Generation     

@Table to define table name 

@Column to define column 

#) Relationships:-

Flat Relationship

One-to-One Relationship

Many-to-One Relationship

One-to-Many Relationship

Many-to-Many Relationship

#) primitive system data types :-

A system data type is a required format for data stored in Appian and includes primitive types and complex types. Each system data type can be used to store either a single value or a list of values.

The following primitive system data types are available

• Boolean
• Date
• Date and Time
• Encrypted Text
• Number (Decimal)
• Number (Integer)
• Text
• Time

#) Complex System Data Types :-

The following complex system types are made available in the system to support smart services.

These types cannot be edited or deleted. Their XML structure is not guaranteed to remain the same from release to release.

• ApplicationTestResult
• DataSubset
• EntityData
• EntityDataIdentifiers
• HealthCheckOutput
• IntegrationError
• LabelValue
• LabelValueTable
• ListViewItem
• Facet
• FacetOption
• ObjectTestResult
• PagingInfo
• ProcessInfo
• Query
• Save
• SortInfo
• TestCaseResult
• TestRunResult
• Writer

#) Appian Object Data Types :-

An Appian Object data type is a required format for objects specific to the Appian system. Similar to primitive and complex system types, each can be used to store either a single value or a list of values.

Appian Object data types are only recognizable within the Appian system.

• Application
• Connected System
• Data Store Entity
• Document
• Document Management Community
• Document or Folder
• Email Address
• Email Recipient
• Folder
• Group
• Knowledge Center
• Process
• Process Model
• Record Action
• Record Data
• Record Field
• Record Identifier
• Record Relationship
• Record Type
• Report
• SafeURI
• Task
• Task Report
• User
• User or Group
• User Filter

#) Record Data Types :-

This data type holds the data definition for all of the fields in a record type (or a subset of fields defined by your record type configuration), as well as the data values for the record.

When you make changes to the record type object, the record data type is also updated and stays current with any configuration changes you make. 

For example, if you change the name of a record field on a record type, the change is also captured on the record data type.

The record data type allows you to easily pass record data to your interfaces, records-powered components, and expression rules.

For More Info :- Click here (Appian Site)

Note : Source of the information posted is from www.appian.com , Wikipedia and from internet.

Appian Best Practices :-

   1) Best practices for creating Application

    2) Best practices for creating CDT & Data Store

    3) Best practices for creating Group

   4) Best practices for Creating KC & Documents 

   5) Best practices for Creating Process Model

   6) Best practices for Creating Rules & Constants

   7) Best practices for Creating Records

   8) Best practices for Creating Reports

   9) Best practices for Creating Sites

 10) Best practices for Creating Sail

 11) Best practices for Creating Process Reports

 12) Best practices for Creating Integration

 13) Best practices for Creating Web APIs

 14) Best practices for Security

 15) Best practices for Application Performance and Scalability Standards

 16) Best practices for Database Management Standards

 17) Best practices for Application Import/Export

 

Appian Annotations - 2

JPA Annotations :-

JPA annotations are used in mapping java objects to the database tables, columns etc. Today we will look into Appian supported JPA annotations.

When used with Data Stores, a custom data type (CDT) can be used to map data to a relational database. Your custom data types can use JPA annotations in the XSD (XML Schema Definition) to map types and their fields to tables and columns within a database.

Many of the supported JPA annotations are automatically added for you when creating a custom data type (CDT) from a database table or when defining CDT relationships in the data type designer. Should you need to add additional JPA (Java Persistence API) annotations to your XSD (XML Schema Definition), this section contains the list of all Appian supported annotations.

The following annotations are supported: 

16) @JoinTable

The @JoinTable annotation is used to specify the link table between two other database tables.

17) @Lob

The @Lob annotation is used to specify that the currently annotated entity attribute represents a large object type.

18) @MappedSuperclass

The @MappedSuperclass annotation is used to specify that the currently annotated type attributes are inherited by any subclass entity.

19) @OrderBy

The @OrderBy annotation is used to specify the entity attributes used for sorting when fetching the currently annotated collection.

20) @PrimaryKeyJoinColumn

The @PrimaryKeyJoinColumn annotation is used to specify that the primary key column of the currently annotated entity is also a foreign key to some other entity (e.g. a base class table in a JOINED inheritance strategy, the primary table in a secondary table mapping, or the parent table in a @OneToOne relationship).

21) @PrimaryKeyJoinColumns

The @PrimaryKeyJoinColumns annotation is used to group multiple @PrimaryKeyJoinColumn annotations.

22) @SecondaryTable

The @SecondaryTable annotation is used to specify a secondary table for the currently annotated entity.

23) @SecondaryTables

The @SecondaryTables annotation is used to group multiple @SecondaryTable annotations.

24) @SequenceGenerator

The @SequenceGenerator annotation is used to specify the database sequence used by the identifier generator of the currently annotated entity.

25) @Table

The @Table annotation is used to specify the primary table of the currently annotated entity.

26) @TableGenerator

The @TableGenerator annotation is used to specify the database table used by the identity generator of the currently annotated entity.

27) @Temporal

The @Temporal annotation is used to specify the TemporalType of the currently annotated java.util.Date or java.util.Calendar entity attribute.

28) @Transient

The @Transient annotation is used to specify that a given entity attribute should not be persisted.

29) @UniqueConstraint

The @UniqueConstraint annotation is used to specify a unique constraint to be included by the automated schema generator for the primary or secondary table associated with the currently annotated entity.

30) @Version

The @Version annotation is used to specify the version attribute used for optimistic locking.

31) @ManyToMany

The @ManyToMany annotation is used to specify a many-to-many database relationship.

32) @ManyToOne

The @ManyToOne annotation is used to specify a many-to-one database relationship. (with additional value of NONE for cascade attribute; default value of cascade is MERGE, PERSIST, REFRESH)

33) @OneToMany

The @OneToMany annotation is used to specify a one-to-many database relationship.(default value of cascade is ALL, which includes deleting orphans)

34) @OneToOne

The @OneToOne annotation is used to specify a one-to-one database relationship.

Appian Annotations - 1 :-   Click Here

Source : shorturl.at/fjlmY

Source : https://docs.appian.com/suite/help/22.2/Supported_XSD_Elements_and_JPA_Annotations.html