Step-by-Step Guide: Setting Up OpenIRS-UCM + Moodle

Integrating OpenIRS-UCM with Moodle for Seamless eLearning### Overview

Integrating OpenIRS-UCM with Moodle brings together a robust university content management and institutional repository system (OpenIRS-UCM) and a leading open-source learning management system (Moodle). The goal is to create a seamless digital learning environment where course content, research outputs, administrative documents, and learning activities are managed, shared, and reused efficiently across the institution.

Why integrate OpenIRS-UCM with Moodle?

Centralized content lifecycle: Manage content creation, review, publishing, and archival in OpenIRS-UCM while exposing approved content to Moodle courses.
Single source of truth: Avoid duplication and version drift by linking course materials and repository items to the authoritative records in OpenIRS-UCM.
Improved discoverability: Repository metadata and search features make it easier for educators and students to find relevant resources from within Moodle.
Compliance and preservation: Institutional policies (copyright, retention, accreditation) are enforced in the repository before materials reach course pages.
Research—teaching synergy: Faculty can surface research outputs, datasets, and multimedia from OpenIRS-UCM directly in learning activities, enriching curriculum relevance.

Key integration use cases

Embedding repository-hosted documents, datasets, and multimedia into Moodle course pages, lessons, and activities.
Automatic enrollment-based content provisioning: when a student enrolls in a course, they receive curated reading lists pulled from repository collections.
Synchronizing metadata and access rights—Moodle’s course roles map to repository access levels.
Citation and DOI linking: course material references persistent identifiers from OpenIRS-UCM.
Analytics and reporting: combined usage metrics to inform teaching and collection development.

High-level architecture

Integration can be thought of in three layers:

Presentation layer
- Moodle displays repository items via embedded viewers, links, or LTI-like tools.
Application/service layer
- Middleware or plugins handle authentication, authorization, metadata exchange, and content transformations (e.g., convert repository PDFs to web-friendly viewers).
Data layer
- OpenIRS-UCM’s repository, metadata stores (e.g., Dublin Core, MODS), and asset storage; Moodle’s course, user, and activity databases.

Authentication & Authorization

Choose an identity management approach that supports single sign-on (SSO) so users switch between Moodle and OpenIRS-UCM seamlessly:

SAML (Shibboleth, SimpleSAMLphp)
OAuth2 / OpenID Connect
LDAP for backend provisioning

Map Moodle roles (student, teacher, manager) to repository permissions so content visibility respects course enrollment and institutional policies.

Metadata and content exchange

Use common metadata standards (Dublin Core, Schema.org) to enable consistent discovery.
Expose repository items through RESTful APIs or OAI-PMH endpoints for harvesting.
Implement metadata mapping: repository fields → Moodle resource descriptors (title, abstract, authors, keywords, DOI).
Optionally use JSON-LD for rich, machine-readable metadata that improves search and compatibility.

Integration methods

Moodle plugin (recommended)
- Develop or use an existing plugin that embeds OpenIRS-UCM items into Moodle resources (URL, File, Page, Book). The plugin handles API calls, authentication token exchange, and in-place viewers.
LTI (Learning Tools Interoperability)
- If OpenIRS-UCM can act as an LTI tool provider, courses can add repository tools that launch authenticated sessions and allow content selection.
REST API / Web services
- Custom integrations retrieving repository metadata and files, then creating Moodle resources programmatically via Moodle’s web services.
Federated search
- Add repository as a search source within Moodle’s search or via a block that queries OpenIRS-UCM.
Content packaging
- Export curated collections as IMS Content Packages or Common Cartridge for import into Moodle courses.

File handling and viewers

Serve large multimedia and datasets from OpenIRS-UCM storage with streaming support rather than duplicating files in Moodle.
Integrate web viewers (PDF.js, MediaElement.js) within Moodle pages to present repository content inline.
Provide derivative assets (thumbnails, web-optimized video) to improve load times and accessibility.

Workflow and editorial control

Define workflows so only approved/released items are visible to students.
Use collection-based access: course collections in OpenIRS-UCM linked to Moodle course IDs.
Allow instructors to request repository items be added to courses; repository staff manage rights clearance and metadata quality.

Accessibility & compliance

Ensure repository content follows accessibility standards (WCAG 2.1 AA).
Provide transcripts/captions for audio/video.
Preserve accessible source formats (HTML, tagged PDF) in the repository so Moodle can present them correctly.

Analytics and reporting

Correlate repository downloads/views with Moodle activity logs to understand resource impact.
Use aggregated reports to guide collection building and instructional design.
Consider xAPI/Tin Can for richer learning analytics when content is used as interactive learning objects.

Security considerations

Enforce HTTPS everywhere and secure token handling.
Use scoped API keys or OAuth tokens and rotate credentials.
Audit logs for content access and exports.
Respect copyright and license metadata when surfacing items to courses.

Implementation steps (practical roadmap)

Requirements gathering: stakeholders, use cases, data flows.
Choose SSO and agree on role mappings.
Prototype a Moodle plugin or LTI tool for simple embedding of repository items.
Implement metadata mappings and API endpoints.
Pilot with a small number of courses; gather feedback.
Expand, add automation (enrollment-based provisioning), and refine workflows.
Provide training and documentation for instructors and repository staff.
Monitor usage, accessibility compliance, and iterate.

Example: Simple plugin workflow

Instructor clicks “Add repository item” in a course.
Plugin opens a chooser interface authenticated via SSO.
Instructor selects items (documents, video, dataset); plugin creates Moodle resource entries that reference repository URLs and metadata.
Students access the resource inline in the course; access is checked against repository permissions.

Risks and mitigation

Permission mismatches — mitigate by clear role mapping and testing.
Performance issues when streaming large files — use CDN or enable streaming in repository storage.
Metadata inconsistency — enforce templates and validation rules in OpenIRS-UCM.

Cost & maintenance

Development effort for plugins/LTI or middleware.
Ongoing maintenance for API changes, security patches, and SSO updates.
Training for staff and faculty.

Conclusion

Integrating OpenIRS-UCM with Moodle creates a powerful, maintainable ecosystem that improves content management, supports academic workflows, and enriches learning. Start with a focused pilot (embedding and role mapping) and expand toward automated provisioning, analytics, and richer tool integration as needs become clearer.