Learn from Peter Tucker how to move documents using either the clipboard or drag-and-drop.
Moving Documents in Nuxeo Platform
Learn from Peter Tucker how to move documents using either the clipboard or drag-and-drop.
Learn from Peter Tucker how to move documents using either the clipboard or drag-and-drop.
Join engineer Peter Tucker for a look at drag and drop uploading, annotation, and storyboards in Nuxeo’s DAM.
This tutorial is the second part of a three part series of blog posts where we walk you through the process in which to successfully deploy the default UC Berkeley CollectionSpace Django web application on a production server. The first part, ‘’Installing and Configuring the Dependencies,” can be found here. In this tutorial we will perform the following in order to successfully deploy our Django web application:
Before we get started, let’s recap on CollectionSpace, the Django web application, and what was covered in the preceding tutorial.
CollectionSpace is an open-source, community based, web application built for museum and collection institutions to manage their internal collections. You can learn more about CollectionSpace by visiting www.collectionspace.org.
The CollectionSpace Django web application is also open-source and community based, but represents a public facing site with many available internal applications such as:
To preview several deployments of the Django web application, navigate to webapps.cspace.berkeley.edu. In addition, the source code can be found at github.com/cspace-deployment/cspace_django_project.
In part one of this tutorial, we installed and configured the various dependencies needed to run the Django web application in a production environment, these included:
Now that we have all of the background thoroughly covered, let’s begin with part two of this series. Our assumptions are that you’ve successfully completed the preceding tutorial and you currently have Solr and Apache2 running as a service on your machine. If not, feel free to contact us for help or post on the CollectionSpace Talk list.
Navigate to the shared directory at /usr/local/share or more specifically:
$ cd /usr/local/share/
From within the above directory, make a new directory called “django” and within this django directory, a new subdirectory called “webapp” by executing:
$ sudo mkdir -p django/webapp
Next, navigate into the webapp directory:
$ cd /usr/local/share/django/webapp/
Now, get the source code by cloning the remote GitHub repository, locally:
$ sudo git clone https://github.com/cspace-deployment/cspace_django_project.git
On the off chance that you may not have ‘git’ installed on your machine, run:
$ sudo apt-get install git
That should do it, as far as obtaining the latest and greatest source code.
Now, copy all of the files found in the ‘cspace_django_project’ directory to the parent directory, ‘webapp’, by executing, from within the ‘webapp’ directory:
$ sudo cp -r cspace_django_project/* .
Then, after effectively copying all the files, remove the ‘cspace_django_directory’ by executing:
$ sudo rm -r cspace_django_directory
Now that we have the source code, we need to ensure that the dependencies required for this project remain separate of other Python projects on our machine. This is accomplished by isolating our project using the Virtual Environment tool, which was installed in part of this series. However, in order to begin, we still need to set some path variables for our virtual environments. To do so, execute the following commands, from within the webapp directory:
Note: although it’s possible to use the virtual environment wrapper (virtualenvwrapper) tool, you are likely to run into various permission issues that can easily be avoided by using the simple virtual environment tool (virtualenv).
$ sudo su
Warning: we are now the root user of the machine, be careful and mindful of what you do as the root user.
Now, create a virtual environment for our project, while still in the webapp directory, by running:
# virtualenv cspace_venv
Note: the ’#’ indicates that the current user is the root user. And (cspace_venv) indicates the current working virtual environment.
We are now ready to begin working in our dedicated virtual environment, ‘cspace_venv.’ You may now see the prefix ‘(cspace_venv)’ on the current line, defining the current working virtual environment. If not, run:
# source cspace_venv/bin/activate
A couple of useful commands to take note of:
(cspace_venv) # deactivate
Deactivates the current working virtual environment.
# rm -rf [name of the virtual environment to remove]
Which will remove any defined virtual environment, by simply deleting its directory.
Moving on, install the web application’s requirements within ‘cspace_venv’ by executing:
(cspace_venv) # pip install -r pycharm_requirements.txt
As suggested in the project readme, the dependencies found in the pycharm_requirements.txt are the least resource intensive, and simplest to install.
If that fails with something like “Command ‘python setup.py egg_info’ failed with error code 1 in /tmp/pip-build-dUM8oT/PyGreSQL/”, try the following:
# apt-get install python-psycopg2
# apt-get install libpq-dev
(cspace_venv) # pip install -r pycharm_requirements.txt
The dependency requirements should now install fully, and you should be prompted with “successfully installed Pillow-2.5.3 PyGreSQL-4.1.1 …..” If not, we would suggest searching for the error you may receive and posting to the CollectionSpace Talk list.
Next, install the Apache mod_wsgi module by executing:
# apt-get install libapache2-mod-wsgi
This module is used to host Python standard WSGI applications on an Apache server. You can read more about it here: https://docs.djangoproject.com/en/1.9/howto/deployment/wsgi/modwsgi/
The next step is to ensure that all of the configuration files are in the right place for our deployment. Example configuration files can be found in the ‘config.examples’ directory. For a default deployment on a production server, these configuration files are adequate. Therefore, will will need to move them to the ‘config’ directory in order to satisfy the applications configuration requirements. To do so, from within the ‘webapp’ directory, execute the command’:
# cp -r config.examples/*.cfg config
(cspace_venv) # ./setup.sh configure pycharm
(cspace_venv) # ./setup.sh deploy default
You will likely see a bunch of warnings, ignore them for now.
We’ll need to make some additions to the wsgi.py script found in the ‘django/webapp/cspace_django_site’ directory in order to activate and point to the dedicated virtual environment, containing module dependencies we installed earlier, upon deployment.
Using your preferred command line text editing tool, add the following statements and expressions at the specified line numbers. We are not removing any lines, just adding them:
1 import site . . 11 # Activate virtual environment 12 activate_env = os.path.expanduser('/usr/local/share/django/webapp/cspace_venv/bin/activate_this.py') 13 execfile(activate_env, dict(__file__=activate_env))
Configure the Apache2 server to communicate with the Django web application by copying the provided file 000-default.conf found in ‘django/webapp/config.examples’ and overriding Apache2’s default configuration file. However, before doing so, following the instructions in the provided configuration file and then ensure that lines 50-52 are the following, adding them if necessary:
50 WSGIDaemonProcess webapp_wsgi python-path=/usr/local/share/django/webapp:/usr/local/share/django/webapp/cspace_venv/lib/python2.7/site-packages
51 WSGIProcessGroup webapp_wsgi
52 WSGIScriptAlias /webapp /usr/local/share/django/webapp/cspace_django_site/wsgi.py process-group=webapp_wsgi
Do not remove any lines, just comment them out to be safe.
Then, save your edits and copy the provided configuration file to the Apache2 directory by executing:
# cp -f ./000-default.conf /etc/apache2/site-enabled/
Excellent, now collect the static files by executing, from within the ‘webapp’ directory:
(cspace_venv)# python manage.py collectstatic
Note: make sure you are still working in the ‘cspace_venv’ dedicated virtual environment, otherwise you will receive errors.
Type ‘yes’, effectively collecting all of the static files in STATIC_ROOT.
Then, restart the Apache2 server:
# service apache2 restart
Visit ‘<your_ip_address>/webapp’ in your browser to ensure the webapp was deployed successfully. If all went well, you should be seeing:
And, clicking the ‘search’ button, effectively directing us to the search application, you should see:
However, if you run into errors, check the Apache2 server log located at /var/logs/apache2/error.log by executing:
# tail -f /var/logs/apache2/error.log
Back in the ‘webapp’ directory, you may need to disable many of the pre-installed web applications by first, listing the currently installed apps:
(cspace_venv)# ./setup show
And, disabling any that may be causing problems, for example:
(cspace_venv)# ./setup disable hello
If all went well, you should now be able to access and view your new UCB CollectionSpace Django web application from your browser, including the the public search application. If not, continue to troubleshoot by using the Apache2 error.log, and as always, feel free to post any difficulties on the CollectionSpace Talk list.
Okay, so we are not completely out of the woods yet. You’ll notice that any queries performed in the search application returns no list of records. Now you’re likely asking, “Yousuf, what gives?”
Well, this is due to the fact that we have yet to configure Solr to talk to our CollectionSpace PostgreSQL database. That, we will cover in the next post in this series, along with:
As always, we hope you found this tutorial useful and we look forward to seeing you as part of the growing CollectionSpace community. For questions about how CollectionSpace can help manage your museum collections, feel free to contact us and our development team here at Granite Horizon.
With the countless Museum Collection Management (MCM) platforms that exist, choosing one that fits your organization’s workflows and budget can be a headache. We’ll attempt to relieve this headache, ever so slightly, by comparing two popular MCM platforms, CollectionSpace (CS) and PastPerfect (PP). The information that follows, other than comments, is sourced directly from CS (v4.3) and PP (v5.0) current release documentation. We even provide links, so you can easily research a discussed feature of the corresponding platform.
The categories for comparison include:
Let’s begin with a brief description of each MCM platform, derived directly from their web-pages, before moving on to our side-by-side comparisons.
“CollectionSpace is a web-based, open source collections management and information system for museums and other collecting institutions. You can use it to manage your museum’s cataloging, acquisitions, loans, and many other activities.”
“The CollectionSpace team and community is made up of museum professionals, software engineers, and interaction designers.”
“PastPerfect is the world’s leading software program for collection and contact management. Over 9,000 organizations worldwide have achieved their goals using PastPerfect”
“It handles accessions, descriptive cataloging, loans, exhibits, capital campaigns, membership development, pledges, dues, donation receipts, research, lexicons, and reports.”
|PP: the remaining information about the PP platform is unknown. We can assume that it uses Microsoft based languages and technologies at its core. Unfortunately, the database back-end (FoxPro) is no longer supported by Microsoft. However, the team at PP assure users that this will not affect the quality and reliability of current and future releases.|
|Interface||Web application||Desktop application||CS: can be accessed from any computer through the web browser, unless otherwise configured for specific ip-addresses|
|PP: access is done on a single computer, or with an upgrade, over a network for authorized computers|
|Supported Host Server OS||Linux, Mac, Windows||Windows||CS: setting up on a Linux Ubuntu distribution is preferred|
|PP: requires purchase of Windows OS and other Windows software|
|Installation||Requires developer knowledge *||CD (single computer). Requires sysadmin knowledge (network).||CS: installing can be development heavy, but the process is second nature to CS developers. The CS server can be installed on any OS listed above|
|PP: installing on a single computer is simple for anyone with basic computer knowledge. Installing on a network, however, requires knowledge of Windows Network OS, a dedicated network computer, network cards on each computer, and purchase of the PP network upgrade|
|Upgrading||Requires a CS developer to successfully upgrade from older versions||Provides an import feature to migrate data from older versions||CS: the steps to upgrade from an older version accommodate every new release|
|PP: thanks to the import feature upgrading from older version appears easy. Upgrades must be purchased from PP|
|Core||YES||YES||CS: includes fields and procedures common to most collecting organizations|
|PP: conforms to latest standards for cataloging archive, library, historic object, art object, natural history, archeology, and photographic collections|
|Anthropology||YES||NO||CS: includes fields and procedures useful for collections of anthropology and ethnography|
|PP: see core comments|
|Botanical Gardens||YES||NO||CS: includes fields and procedures useful for living plant collections|
|PP: see core comments|
|Fine and Contemporary Art||YES||NO||CS: includes fields and procedures useful for collections of fine and contemporary art|
|PP: see core comments|
|Herbarium||YES||NO||CS: includes fields and procedures useful for preserved plant specimen collections|
|PP: see core comments|
|Local History and Material Culture||YES||NO||CS: includes fields and procedures useful for local history and material culture collections|
|PP: see core comments|
|User Friendly||YES||YES||CS: easy to navigate, clear distinction between features, concise labeling|
|PP: easy to navigate, clearly labeled features, simple|
|Attractive *||?||?||CS: colorful, modern, and uncluttered. See screen-shots below.|
|PP: somewhat sterile, grey, and slightly cluttered. See screen-shots below.|
|Easily Customizable||YES||NO||CS: a web application that can be easily customized|
|PP: a desktop application that is not customizable|
* This is entirely subjective, ultimately it’s up to you to decide.
In order to avoid any copyright infringement, we have chosen not to provide any screen-shots of the PastPerfect platform, but you can find many of them in the user manual found at http://pastperfect-online.com/webhelp/Chapters/PP5-6e.htm.
|Custom Groups and Permissions||YES||YES||CS: each custom user role you create is defined by 22 parameters and the refined even further with read, write, delete, and none. Read more.|
|PP: an optional feature when creating a new user, it’s possible to create groups and refine permissions in all program areas. Read more.|
|Custom User Permissions||YES||YES||CS: this is configured from the Administration tab of the platform. Can specify the specific role of the user.|
|PP: by adding a users to a custom group, the security settings of the group are enforced upon the user. Read more.|
|User Forgot Password||YES||NO||CS: a link is provided at the login page to reset your password. Clicking the link sends a message to your email with password reset. Instructions. Read more.|
|PP: as far as we can tell, PP does not provide the user the ability to reset a forgotten password.|
|User Documentation||YES||YES||CS: a constantly evolving document, the user manual is not very comprehensive and you’ll find some sections that are missing. However, having access to the various profile demos answers a lot of questions. Read more.|
|PP: a comprehensive and well written online user guide is available through the website. Read more.|
|Developer Documentation||YES||YES, but limited to only the public facing site or Virtual Exhibit||CS: extensive developer documentation can be found through CS on the project’s Wiki page. This includes both the platform itself and the deployable public facing site. Read more.|
|PP: you can find documentation on how to configure your Virtual Exhibit using the built in tools, HTML, and CSS. Read more.|
|Active Q&A Forum||YES||YES||CS: a very active email list is used by both CS implementers and developers. Responses, on average, are heard within 24 hours. Read more.|
|PP: questions and answers can be found on PP’s support page, under Knowledge Base. Read more.|
|Software Help||YES||YES||CS: available through contacting service providers, asking a question on the CS Talk list, and even contacting the CS program staff regarding core technical information.|
|PP: in general, PP provides 24 hour support, giving priority towards customers who pay for annual support services. Read more.|
|Deployment||Requires developer knowledge||Require purchase of addon and setup, see pricing for details||CS: the source code for a public facing site is free. Uses Django and CS Rest API’s. Built by the development team at UC Berkeley. It is highly configurable to the look and feel of your organization. Read more.|
|PP: called the Virtual Exhibit (VE), a web tool is available through the PP interface. Read more.|
|Public Collection Search||YES||NO, but see comments for more details||CS: “public (non-authenticating) search appliance”|
|PP: pastperfect-online.com provides the ability to search the collections of all PP accounts. The VE does not provide a search feature.|
|Internal Collection Search||YES||NO||CS: “internal (authenticating) search appliance”|
|Browse Collection||YES, but see comments for further details||YES||CS: is accomplished through other web apps such as ‘Image Browser’ (below)|
|PP: the primary functionality of the VE is the ability to browse the accounts collections|
|Records Export||YES||NO||CS: returned search results can be exported as a CSV or XML document|
|Image Browser||YES||NO||CS: “a ‘lightbox-like’ app that tiles images based on a keyword query to Solr backend”|
|Image Server||YES||NO||CS: “cacheing proxy server to serve images from CSpace server”|
|Imaginator||YES||NO||CS: “‘google-lookalike’ search app — provides ‘N blue links’ for a keyword search”|
|Bulk Media Upload||YES||NO||CS: uses the REST API to bulk upload Media Handlers up to 100 at a time to the CS server|
|Batch Image Upload||YES||NO||CS: uses the REST API to upload images in bulk to the CS server|
|Mobile Compatible||YES||?||CS: provides mobile device support for public facing site|
|PP: no documentation could be found on mobile compatibility of the VE|
* The code for all available CS apps can be found on the UC Berkeley CSpace Django Project GitHub repository, found here.
** The page found at http://museumsoftware.com/ve_samples/basic/index.htm provides a basic online PP Virtual Exhibit.
|REST API||YES||NO||CS: you’ll find API’s for each layer of the CollectionSpace platform, which include the service layer, application layer, and interface layer. Read more|
|PP: not applicable, since the software is owned and operated by PastPerfect Software, Inc|
|Customization||YES||NO||CS: as an Open Source Initiative and operating under a Educational Community License, the source code is available for anyone to view, download, and modify as they see fit. Read more.|
|PP: see REST API notes.|
|Software||Free||$870 for initial install and $375 for version upgrades||CS: opensource and free to download. Licensed under the Educational Community License, Version 2.0. Membership is available to help support the project and ensure the software is available for years to come. Read more.|
|PP: covers a single single user/machine, additional users would require the Network Upgrade. Read more.|
|Multimedia||Included||MultiMedia Upgrade: $385||CS: this comes included with your CSpace instance|
|PP: attach digital images and multimedia files to collection records. Read more.|
|Users||Free||$515 (2-5 users), $900 (6-10 users), $1240 (11-25 users), $1650 (unlimited users)||CS: web based software can be accessed from anywhere for authorized users|
|PP: allows shared access to data by setting up multiple workstations|
|Public Facing Site||Free, but see comment||$285 (setup), $450 (hosting first 10,000 records), $245 (each additional 10,000)||CS: requires development knowledge to deploy the web application, and other web applications already developed by UC Berkeley|
|PP: one time setup fee with subsequent scaling fees|
|Inventory Management||Free||$295||CS: included in the ‘iReports’ web app, and through the CS platform|
|PP: provides to tools to implement “successful collection tracking projects”. “This add-on product makes it simple to create inventory lists, print barcode labels, track collections electronically, and ensure accurate records”|
|Barcode Printing||See comment||$125||CS: not available, but can be added by a developer and service provider|
|PP: allows for quick “artifact marking and tracking and inventory control”|
|Training||Free, see comment||$119 (3 CD Set + User Guide), $39 (Cataloging Collections), $39 (Managing Contacts, Donations, & Memberships), $39 (Research & Reporting)||CS: a series of Youtube training videos have been developed and are available to anyone|
|PP: can be purchased individually or as a set. Provides a way to orient staff and volunteers on the workings of PP|
|Hosting||See comment||See comment||CS: can be hosted on any type of OS compatible server (i.e. Amazon Web Services). Price varies according to your selected service provider|
|PP: varies depending on the selected add-ons and internal network setup|
|Support||YES, see comment||$345 (first year, single user), $425 (first year network), $440 (annual single user), $540 (annual network 2-10 users), $745 (annual network 11+ users), $85 (per-incident for non-support clients)||CS: can be provided by your service provider, or if done internally, through the Talk list and through contacting the CS development team|
|PP: 24 hour support, where annual support service customers have priority. Calls are said to be returned within the hour|
* A 20% discount for Institutional Members of the American Association for State and Local History. A complete price list for PastPerfect can be found at http://museumsoftware.com/pricing.html.
To be able to cover the content management capabilities of each platform, it would easily take an entire blog post for each. Even then, we still don’t think we’d be able to cover everything these platforms have to offer. Instead, we encourage you to explore each platform on your own. Both PastPerfect and CollectionSpace provide free demos for their individual platforms.
For CollectionSpace, you can try out all of the available profiles mentioned above in addition to various implementations of the public facing site simply by navigating to the following pages:
For PastPerfect, you can download and evaluate the latest release on a machine running the Windows OS, such as XP, Vista, 7, 8, and 10, after completing their mandatory information form. The download page can be found by navigating to:
When it boils down to making the ultimate decision on which platform to integrate into your organization, there are several major questions to consider. For example, to list only a few:
To summarize our findings, PastPerfect, built by PastPerfect Software, Inc., is a highly structured and reliable MCM platform that runs on a Microsoft Windows desktop, either locally, or over a Microsoft network. Various tools are provided to make migrations and web deployment relatively easy and simple. In addition, addons are available to extend the capabilities of your platform even further. The user documentation is extensive and well written. However, the facts that the platform and its addon features are only available at a cost, it is Microsoft dependent, lacks an available developer API, and the UI seems relatively outdated can be somewhat discouraging if these given facts are of value to you. Overall, PastPerfect’s reliability, features, and solid support may outshine these areas in which it lacks.
CollectionSpace, on the other hand, is an open source, community based, web application that provides a lot of freedom in who, what, and how it is configured. Of course, being an open source, community based application, its success relies heavily on the activity of the community and the support it receives through memberships, grants, donated developer time from universities and colleges, and stewardship by Lyrasis. The architecture and design is modern, flexible and highly capable. The platforms available features and various pre-configured profiles make it a very attractive option right out of the box. At its price point, we can only expect the platform’s popularity and support to increase within the foreseeable future.
We hope this post helps ease the headache that comes with having to make the decision on which Museum Collection Management platform to adopt. If you have any questions regarding CollectionSpace and how it can meet your organization’s needs, please feel free to reach out as we would be happy to help (contact us). Also, we encourage your comments on anything discussed in this post. Please, feel free to add your comment below.
Thanks to the hard-working developers at UC Berkeley, organizations that use the CollectionSpace platform, “a web-based, open source collections management and information system for museums and other collecting institutions,” can now deploy and extend their very own web applications. We are going to show you how on a production server
Built on Python’s popular web framework, Django, the web applications are highly customizable. By default, they provide two core features. These are:
Most of what you need to know, and things you would like to know, can be found on UC Berkeley’s GitHub repository. For deploying the default webapp specifically, you will need to go to their CSpace Django Project. Be sure read what’s published in the readme as familiarizing yourself with the many terms and processes will only help make deployment easier.
We assume that you already have an instance of CollectionSpace running on your desired server. If not, please refer to the CollectionSpace Installation Wiki to learn how.
Before you do anything, make sure to update any existing packages:
$ sudo apt-get update
In a terminal window, assuming that your current user has sudo permission, run the command:
$ sudo apt install apache2
This will install the Apache2 web server at the directory /etc/apache2.
Start up the Apache2 web server by executing:
$ service apache2 start
You should be prompted with:
“* Starting web server apache2”
Other helpful, self explanatory, commands include:
$ service apache2 [ status | stop | restart ]
By default, the Apache2 web server runs on port 80. With that said, if the installation was successful, navigating to http://<your ip-address> will display the default Apache2 web server page. Use http://localhost if the installation was done on your local machine.
Apache Solr is what UC Berkeley web applications use to search and navigate through your CollectionSpace instance. We recommend that you go beyond the documentation we provide here and what has been provided at the CSpace Django Project GitHub repository. You can download and view the full Apache Solr guide at:
“Solr is highly reliable, scalable and fault tolerant, providing distributed indexing, replication and load-balanced querying, automated failover and recovery, centralized configuration and more.”
Continuing with the installation, in your terminal window, go to your home directory:
$ cd ~
Download the latest version of Apache Solr from Solr’s downloads into your home directory. As of June 2016, the latest version is 6.1.0.
The file name should be remotely similar to this:
Copy the link location and execute the following command in your terminal window:
$ wget [paste link here]
$ wget http://mirrors.ocf.berkeley.edu/apache/lucene/solr/6.1.0/solr-6.1.0.tgz
Once downloaded, go ahead and extract the tar file, replacing “x.y.z” with your downloaded version, specifically extracting the Solr installation script:
$ tar zxf solr-x.y.z.tgz solr-x.y.z/bin/install_solr_service.sh --strip-components=2
Next, install Solr as a service:
$ sudo bash ./install_solr_service.sh solr-x.y.z.tgz
Note: make sure that the current Java version being used by your system meets the dependency requirements for your Solr instance. For release 6.1.0, Solr requires Java version 8. The script will fail otherwise. If you have multiple Java version installed, you can execute the command: sudo update-alternatives –config java to change the version.
If you would like, you can specify various options for the installation.
$ sudo bash ./install_solr_service.sh solr-x.y.z.tgz -i /opt -d /var/solr -u solr -s solr -p 8983
i = install directory for Solr installation archive d = install directory for logs, etc (live writable files) u = user who owns the Solr files s = the service name, which is solr by default p = the port solr should bind to f = for upgrading Solr, overwrites the symlinks and init scripts of old installations. You may need this option if you run into problems with your initial install and would like to try again.
If the command executed successfully, you should be prompted accordingly. For instance:
“ Waiting up to 30 seconds to see Solr running on port 8983 [/]
Started Solr server on port 8983 (pid=10320). Happy searching!
Found 1 Solr nodes:
Solr process 10320 running on port 8983
“version”:”6.1.0 4726c5b2d2efa9ba160b608d46a977d0a6b83f94 – jpountz – 2016-06-13 09:46:58″,
“uptime”:”0 days, 0 hours, 0 minutes, 11 seconds”,
“memory”:”16.9 MB (%3.4) of 490.7 MB”
Service solr installed.”
To make sure Solr installed correctly, visit http://<your ip-address>:8983/solr/#/
If you see the Solr Admin page, you are in great shape!
Again, we recommend taking some time to review the Solr documentation in order to understand how to leverage the full potential of Solr.
Chances are that you already have pip and Python installed on your machine. You can check by executing:
$ python -V
Returning, “Python 2.7.6” (or similar).
Note: For the default UC Berkeley web applications, you’ll need Python 2.7, not 3+.
$ pip -V
Returning, “pip 8.1.1 from /usr/local/python2.7/dist-packages (2.7)” (or similar)
If you discover that you do not have one or more of the above, check out the Hitchhiker’s Guide to Python for instructions on how to resolve these dependencies.
Finally, once you have both Python and pip, do:
$ sudo pip install virtualenv
This installs Python’s virtualenv globally, which we will be using in the second part of this blog post.
To summarize the above, you should now have the following dependencies properly installed and running on your server:
In part 2 of this blog series, we will show you how to successfully configure Solr, Apache2, the default web application, and its corresponding virtual environment. Until then, if you have any questions regarding CollectionSpace or need help deploying your default web application, please feel free to reach out to us.
Congratulations on acquiring your new Nuxeo platform, a feature-rich and highly-customizable place to manage all of your enterprise content. Let’s take a brief tour of your default Nuxeo platform, including accessing your platform, changing your password, and familiarizing yourself with the default layout.
By now, you should be holding the credentials to access your new Nuxeo platform and account, including a link or URL to the platform, username, and password. If not, we suggest contacting your system administrator in order to obtain this information. If you happen to be the system administrator or owner, the default username and password is ’Administrator’, as detailed in the Nuxeo documentation center found on Nuxeo’s website.
When you initially receive your credentials, the first task is to access the platform by clicking on the link provided to you by your system administrator, or going there directly by copying the URL into your web browser bar. Again, check with your system administrator for details. If all goes well, you will be seeing the Nuxeo Platform login page (Figure 1).
Once on the login page, enter the username and password provided to you, while paying close attention to capitalization. This should get you into the Platform. Before you begin exploring, we recommend changing your password from the one that was provided for you. To do this, use the sidebar to the left, containing a list of options starting with ‘Dashboard’. Select ‘Profile’ (Figure 2).
Your profile should contain information regarding your account, such as username, first name, last name, company, and email address. In the upper right corner you’ll find a dropdown button labeled ‘Actions’, select this to activate the drop down menu (Figure 3). Then, select ‘Change Password’. Here you can change your current password to a new, more secure, password.
When you’ve confirmed your new password, select ‘Save’, and you’re done (Figure 4). Changing your password is just that easy. We recommend that you do this often to prevent unwanted users accessing your account.
Now that you’ve secured your password, let’s begin our brief tour of your new default Nuxeo Platform. At the very top of the page (Figure 5), you’ll notice the three main spaces to help with managing your enterprise content, ‘HOME’, ‘WORKSPACE’, and ‘SEARCH’.
Every user has a ‘HOME’ space that provides access to various tabs in the left navigation pane, that are user specific. Appropriately named, this is your home on the Nuxeo Platform. Tabs in this space include (Figure 6):
Moving on we have your ‘WORKSPACE‘. Here you can easily browse your enterprise content repository, access content, collaborate, follow, share, export, and print (Figure 7). On the left, you’ll find the navigation tree, which is a hierarchical folder structure containing your enterprise content. Depending on your content permissions and how your personal workspace is set up, what you see may differ from what is actually available. This is where you’ll be preforming the bulk of your work. Here you can create and manage new or existing content, and collaborate with fellow users. Like the Nuxeo Platform itself, your personal workspace is rich in features and highly-customizable. Take some time familiarizing yourself with the available features as they are tools to help make managing your enterprise content quick and easy.
Last, we have our ‘SEARCH‘ space. This is a very powerful feature of the Nuxeo Platform. Here you have the ability to search your content using a variety of filters (Figure 8). By default, you will have the filters ‘Faceted Search’, ‘Quick Search’, and ‘NXQL Search’. Other filters can be added by your Nuxeo developer or Platform administrator. For example, an ‘Editing’ search filter, as seen in the provided image. The capabilities of the default content search filters include:
Thus concludes our brief tour of your new default Nuxeo Platform. To summarize, we covered how to access the Platform, how to change your password, and the three main spaces of the Platform. We hope that you found this post useful, and we encourage you to explore and familiarize yourself with your new Nuxeo Platform.
As was mentioned before, the Nuxeo Platform is rich in features to help manage your enterprise content. We recommend reviewing Nuxeo’s User Documentation as you’ll find a lot of useful information, tips, and tricks. Feel free to contact us, and our dedicated team of Nuxeo developers, with any questions on how to leverage the power of Nuxeo to meet your Enterprise Content Management (ECM) needs.
Automation chains are made up of multiple bits of instructions called ‘operations’. There are many operations that are already defined in Studio that are generally sufficient for most situations. These operations can include fetching a document, creating a task, and logging in as a specific user to name just a few. When creating an automation chain, a user simply needs to add one operation at a time for the task they have in mind. For example, if they want to have a chain where you login as the administrator and create a new document, they would only need to add the corresponding operations for logging in and creating a document.
The Language is used to create the input values for the operations in an automation chain. MVEL helps determine what metadata should be extracted from specific data types, such as a document file’s title by calling expr:Document[“dc:title”]. With this, you can also set up your own variable names to temporarily hold data, and use them as needed. Here are some basic MVEL scripting features to take note of:
There are many more uses of the MVEL language for automation chains, which can be found at the following link: https://doc.nuxeo.com/display/NXDOC/Use+of+MVEL+in+Automation+Chains.
MVEL also has a list of operators to use, which can be found here: http://mvel.codehaus.org/Operators.
If you are curious to see a sample script that uses MVEL, there’s a posted example which creates a random number guessing game: https://github.com/mvel/mvel/blob/master/samples/scripts/randomguess.mvel.
Even though the Studio provides a vast amount of useful operations, those aren’t the only ones that are usable. Users are freely able to create their own operations themselves. However for this part, the user should be able to code with Java, and be able to utilize MVEL. This requires the installation of the Eclipse IDE, the Nuxeo SDK, and the Nuxeo IDE for Eclipse. The Nuxeo IDE has a wizard to help set up an operation template to give users a start. From here, the users are free to utilize the Nuxeo SDK library to code a specific operation they need. There’s a tutorial to create your first operation which results in the creation of a random string generator:
To see more information related to creating an operation, refer to here too:
These are just the main features associated with automation chains, but I hope this helps anyone get a general idea about the usage of these chains with Nuxeo Studio. Next time, I’d like to elaborate on event handlers, which is the feature responsible for triggering automation chains.
In Nuxeo Platform 7.0, navigate to a document which is ready to be deleted. Then navigate back to the parent document’s Content tab. Check the box next to the name of the document to be deleted. Multiple documents could be selected at this time to be deleted simultaneously. A series of buttons should appear at the bottom of the list of contents once an item is checked. Click the “Delete” button to delete this document (or documents). Then confirm by clicking “OK”.
The parent document can also be deleted. Navigate up a level in the navigation tree, select and delete the parent as well.
Once these documents are deleted, they will no longer appear in the Content tab of the parent document. They will no longer appear on the left navigation tree, either. In order to manage the deleted documents, navigate to the parent of the document that was deleted. In this case, that parent is the Granite Horizon Workspace. Then click the “Manage” tab, and then click the “Trash” subtab.
The action button that is available is “Empty trash”. Select the checkbox next to the parent document (in this case, Granite Horizon Folder) and the options “Permanent delete” and “Restore” appear. Click “Restore” to restore the parent document (Granite Horizon Folder) and all of its subitems. Or, click “Permanent delete” to permanently delete the parent document and all of its subitems. Note that the original child document(s) that were deleted are not listed. Click on the parent document (Granite Horizon Folder) to view the deleted subitems. If the subitems are restored, the parent will be restored as well.
Note that the location where the deleted documents are accessible is the immediate parent document’s Manage/Trash location. In this example, the Granite Horizon Workspace contains the Granite Horizon Folder in the trash. However, the Granite Horizon Workspace’s parent, Workspaces, has nothing in the trash. This may be inconvenient, as it might mean navigating through many documents to find a deleted document. One way around this is to implement a “Domain trash” or a “Workspace trash” at a high level using Nuxeo Studio. This could contain all the deleted documents for that domain and/or workspace. One simple solution to this is to create a content view that shows deleted documents where the path “STARTSWITH” the current document path. The Query filter would look like this:
ecm:mixinType != 'HiddenInNavigation' AND ecm:isCheckedInVersion = 0 AND ecm:currentLifeCycleState = 'deleted' and ecm:path STARTSWITH ?
and the Query parameter is
In order to make this behave like the default Trash tab, add a couple user actions called “Restore” and “Permanent delete”. These can be added directly to the Content View by clicking on “Results” -> Enable additional actions -> Create a new action.
Then add this content view to a Tab on the document desired. Enhance this by adding a search filter.
Out of the box, Nuxeo allows users to delete documents, delete parent documents, restore subtrees and permanently delete subtrees and individual documents. With some customization, some high-level management of deleted documents can be added. Worth noting is that Nuxeo’s delete feature can be controlled by ACLs. In addition, a document’s versions can be deleted using the History -> Archived versions tab. This can also be managed by ACLs.
Any questions or comments? Please chime in!
The document’s History tab contains useful information about a document’s history for every edit: the performed action, the date the action was performed, the name of the user who performed the action, and so forth. When the document is edited, a field for “Change Comment” is available. When an edit is saved, the History -> Event log tab shows the change comment and the version number both in the Comment column. As with most tables in Nuxeo, the Event log can be easily exported to Excel.
The Nuxeo documentation on Document History is available here: http://doc.nuxeo.com/display/USERDOC/Document%27s+History
While the Event log is automatic, with the only user input being the Change Comment, the Versioning system requires direction from the user. The editor can choose to apply a version whenever they edit a versionable document. The editor can increment the version by a major or minor increment, or skip versioning altogether for that edit.
One of the versionable document types that comes with a new Nuxeo installation is the File document. When a File document is edited, the Version section appears, allowing the user to either apply a Major version increment, a Minor version increment, or Skip version increment. Skip is selected by default.
It is interesting to note that the original document is not assigned a version number on creation. Therefore, the History -> Archived versions table only shows a Version if one has been assigned when the document was edited – not when it was created. This means that the original document cannot be retrieved.
When the document is edited again, and another version increment is applied, then true work with versions can begin.
Once a document has two or more versions, the editor can perform a variety of functions on these versions: delete, compare, view, and restore.
The Compare feature renders a diff of the selected versions, if the Nuxeo Diff Marketplace Package has been installed.
Again, it is interesting to note that the original document cannot be compared, deleted, or restored.
This out of the box behavior can be customized to suit business needs.
When a client requires that a specific document type has a version assigned when the document is created, a simple event handler/automation chain can be created that does a major CheckIn when a versionable, regular document is created.
When a client requires that a certain document type, or set of document types, have a Major version assigned whenever the document is edited, the following XML Extension may be helpful:
<extension target="org.nuxeo.ecm.core.versioning.VersioningService" point="versioningRules"> <defaultVersioningRule> <options lifeCycleState="*"> <major default="true"/> </options> </defaultVersioningRule> <versioningRule enabled="false" typeName="File"/> </extension> <require>org.nuxeo.ecm.platform.forms.layouts.webapp.base</require> <extension target="org.nuxeo.ecm.platform.forms.layout.WebLayoutManager" point="layouts"> <layout name="document_edit_form_options"> <templates> <template mode="any">/layouts/layout_default_template.xhtml </template> </templates> <rows> <row> <widget>document_edit_comment</widget> </row> <row> <widget>document_edit_current_version</widget> </row> </rows> </layout> </extension>
Any questions? Have a better solution to share? Please contact us.
Nuxeo Studio is an online service that provides a vast array of features to help users manage their enterprise content better in Nuxeo Platform. Being a user of the service as well as a Nuxeo integration engineer myself, I’d like to list some of the big features Nuxeo Studio has got going for itself.
Studio allows users to define a vast lists of schemes, or collection of metadata (like a potential Football Player schema would include their name, roster number, position, etc.). These help objectify groups of data to have a defined identity so they can be used in a means that makes sense to the user.
Nuxeo Studio provides a nice visual Lifecycle tool to set-up all the possible document states. This includes the starting state and all the possible paths from that state. With this, the studio provides a visual workflow tool that helps users make a roadmap on how documents are handled by users, and how it affects its lifecycle state.
This tool alleviates any unnecessary work to manually create documents, by simply creating a template that automatically produces them. The user can define rules of what type of documents can be created, along with setting up an automatic control list of permissions for the created documents.
Here, the user can define how content is displayed on the platform, as well as define the filter rules on how content can be organized and searched for. To do this, Nuxeo provides NXQL (the Nuxeo Query Language) as a means to query data from its database. It’s a handy language to pick up, and allows the content view to gain access to specific metadata so it can display them in a fashion that suits the users needs.
Users are able to create users actions, automation chains, or event handlers, which allows top-level programming for almost everything with the users content. For automation chains, users can define a string of operations, like simply changing a document property. For user actions, users can apply those automation chains to be triggered when a user does something, like click a button. And for event handlers, users can set an automation chain to be triggered when a special document event happens, like when one is created.
While all of these are standout features of Nuxeo Studio, there are still more things the service can provide.Nuxeo has a vast amount of documentation posted online for everything above, and much more. You can find more information at http://doc.nuxeo.com/display/Studio/Nuxeo+Studio+Documentation+Center.
Granite Horizon, LLC
PO Box 582863
Elk Grove CA 95758-0048
8153 Elk Grove Boulevard Suite 20
Elk Grove CA 95758-5965
(888) 354-6626 (USA)
+1 916 647 6350 (international)