We have now seen a lot of examples of how to get stuff from the repository, what about if we wanted to POST some stuff
to the repository and store it? This is simple, tell the web script container that the web script is of type POST,
and that we expect to upload and store stuff in the repository with it. The key principles of REST involve separating your API into logical resources.
Server-side scripting also enables the website owner to hide the source code that generates the interface, whereas, with client-side scripting, the user has access to all the code received by the client. A downside to the use of server-side scripting is that the client needs to make further requests over the network to the server in order to show new information to the user via the web browser. These requests can slow down the experience for the user, place more load on the server, and prevent the use of the application when the user is disconnected from the server. Server-side scripting is a technique used in web development which involves employing scripts on a web server which produces a response customized for each user’s (client’s) request to the website. Scripts can be written in any of a number of server-side scripting languages that are available. Server-side scripting is distinguished from client-side scripting where embedded scripts, such as JavaScript, are run client-side in a web browser, but both techniques are often used together.
Interpreted versus compiled code
This allows the invocation of a web script using a
mechanism that is natural to the calling environment and to the developer who knows the calling environment. A common client for invoking web scripts is a web browser, as many content rich applications are web applications. The web browser also provides an easy and convenient client for testing web scripts while developing them.
Website scripts require ongoing maintenance and are worthy of your attention. If a third-party script doesn’t add any clear value to your site or users, then consider removing it. To see which scripts are running on your site without getting into source code, you can go to a site like builtwith.com that shows scripts in an easy-to-understand list. The limitation, however, is that this list will not include scripts inside GTM containers.
Understanding web scripts
Java-backed web scripts are web scripts whose controller implementation is written in Java, rather than JavaScript. This indicates to the Web Script Framework that the file
is a resource bundle. If you are using the Alfresco checked-out documents web script as a JSR-168 portlet configured into your portal, when
you uses of a script launch the portal the portal itself asks you to log in. The web script needs to know who is authenticated, so the
Web Script Framework communicates with the portal to determine the currently authenticated user. When the web script is
rendered in the portal page, the web script is invoked as the portal user.
Sometimes when implementing a Web Script there are things that cannot be done in a JavaScript controller, such as accessing
the file system and fetching content on the Internet. To implement a
Web Script controller in Java we create a class that extends the org.springframework.extensions.webscripts.DeclarativeWebScript
class. Using a Java controller will allow us to fetch and process data from wherever we want to. It lets programmers manipulate both backend and front-end elements to integrate popular programming technologies like Java and Tcl at no extra cost. Features like pipe and threads simplify and quicken the task of creating Web applications. A web script uses a response status code to inform the calling client of its execution outcome.
Where are website scripts located?
User agents that don’t recognize the SCRIPT element will likely render
that element’s contents as text. Some scripting engines, including those for
languages JavaScript, VBScript, and Tcl allow the script statements to be
enclosed in an SGML comment. User agents that don’t recognize the SCRIPT
element will thus ignore the comment while smart scripting engines will
understand that the script in comments should be executed. For details on how to extract information from the request
see HTTP requests.
- The first method, getDescription(), returns a WebScriptDescription object, which is a Java representation of the
web script description XML document. - If you terminate your relationship with the provider, the on-page action will stop, but depending on their privacy policy, the script may continue collecting data from your site for their own purposes.
- Either form of scripting (i.e., CGI or direct execution) can be used to build up complex multi-page sites, but direct execution usually results in less overhead because of the lower number of calls to external interpreters.
In fact, we cannot access anything in the
Repository without first authenticating, so using other root objects such as companyhome requires authentication too. Here we use a Content Services-specific JavaScript root object called person to get first and last name of
the logged in user. The model variable is automatically available to us in the controller and we can put whatever data
we want in it for later use in the template. Repository Web Scripts are
defined in XML, JavaScript, and FreeMarker files and stored under alfresco/extension/templates/webscripts.
URI template
For security reasons, solutions like these can run into cross-domain
issues, a restriction that requires you to proxy your requests on the server side. Typically, to work around these issues,
public services, such as Yahoo! JSON Services, provide a callback mechanism. Data web scripts provide a server interface for client applications to query, retrieve, update, and perform processes,
typically using request and response formats such as XML and JSON. By focusing on the RESTful architectural style and ease of development, web scripts let you build your own custom
URI-identified and HTTP accessible content management web services backed by the Content Services server.
There is one special hook point that makes this a useful class for your own Java-backed web scripts to extend. Prior
to controller script execution, DeclarativeWebScript invokes the template method executeImpl(), which it expects
derived Java classes to implement. A pre-built, out-of-the-box web script exists for retrieving the content stream of a document residing in the repository. This web script is CMIS compliant and also specifies its HTTP caching requirements. With the HTTP cache proxy deployed,
the content responses are cached intelligently and the cache is only updated when the content is updated in the repository. This setup will also cache all other responses from web scripts that indicate how they are to be cached.
Deployment – App Server
The result of evaluating the top-level expressions becomes
the HTTP response that the servlet sends back to the client, usually a browser. Server-side code on the other hand is run on the server, then its results are downloaded and displayed in the browser. Examples of popular server-side web languages include PHP, Python, Ruby, ASP.NET, and even JavaScript! JavaScript can also be used as a server-side language, for example in the popular Node.js environment — you can find out more about server-side JavaScript in our Dynamic Websites – Server-side programming topic.
Client-side code is code that is run on the user’s computer — when a web page is viewed, the page’s client-side code is downloaded, then run and displayed by the browser. You might hear the terms interpreted and compiled in the context of programming. In interpreted languages, the code is run from top to bottom and the result of running the code is immediately returned. You don’t have to transform the code into a different form before the browser runs it. The code is received in its programmer-friendly text form and processed directly from that.
Creating resource bundles supporting i18n
Some cache controls can be set only during the execution of a web script, such as setting when the content of the
response was last modified. To support this, the Web Script Framework provides a special root object named cache
to all controller scripts for allowing cache controls to be set at runtime. The simplest Web Script you can write consists of a descriptor and a template. The descriptor will tell you what
URL that should be used to invoke the Web Script.
