# Aumentum Web Access - Flow Analysis

## Overview

Based on the actual Aumentum Web Access frontend files, here's how the system fetches and renders documents.

## Key Discovery

**Server URL**: `http://10.10.10.3:8080/lrswa/`

This is Aumentum's actual web application running on port 8080 (not 1433 which is SQL Server).

## Architecture

```
┌─────────────────────────────────────────────────────────────┐
│                    Browser (ExtJS 3.x)                      │
│                                                              │
│  • Search Forms (forms.js)                                  │
│  • Grid Views (grids.js)                                    │
│  • Document Viewer (imgviewer.js)                           │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       │ AJAX Requests
                       ↓
┌─────────────────────────────────────────────────────────────┐
│          Aumentum LRS Web Access (Java/Spring)              │
│                  http://10.10.10.3:8080/lrswa/              │
│                                                              │
│  Endpoints:                                                  │
│  • /welcome.do        - Main page                           │
│  • /get.do            - Generic data endpoint               │
│  • /documentPage.do   - Document viewer                     │
│  • /details/*.do      - Details templates                   │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       │ Authentication & Content Access
                       ↓
┌─────────────────────────────────────────────────────────────┐
│                 Alfresco Content Services                    │
│                                                              │
│  • Authentication (ticket-based)                             │
│  • Content API (/webapi/...)                                │
│  • Document storage                                          │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ↓
┌─────────────────────────────────────────────────────────────┐
│            SQL Server LRS43 (10.10.10.3:1433)               │
│                                                              │
│  • LRSAdmin.lr_source_document                              │
│  • LRSAdmin.alf_node                                        │
│  • LRSAdmin.alf_content_url                                 │
│  • LRSAdmin.alf_node_properties                             │
└─────────────────────────────────────────────────────────────┘
```

## Document Retrieval Flow

### 1. **User Searches for Documents**

**Frontend (`forms.js`)**:
```javascript
// User submits search form
form.addButton({text: btnSearchText}, function(btn, e){
    var qo = f.getForm().getValues();
    qo[doQueryIdName] = '1';
    q = objectValues2String(qo);
    var token = tabResultIdPrefix + tokenDelimiter + fc.type + tokenDelimiter + q;
    historyAdd(token);
});
```

**Backend Request**:
```
GET http://10.10.10.3:8080/lrswa/get.do?h=<handler>&q=<query>
```

### 2. **Search Results Display**

The grid loads search results with document metadata including:
- Document Number (e.g., `BP3208`)
- Document Type
- Date
- **UUID** (critical for document retrieval)

### 3. **Document Viewing Flow**

**Frontend (`imgviewer.js`)**:
```javascript
function getURLById(imgId) {
    var url = getImageBaseUrl(document.URL) + '/documentPage.do?uuid=' + imgId;
    return url;
}
```

**Key Insight**: Documents are accessed via **UUID**, not `document_number`.

### 4. **Alfresco Authentication Flow**

**Frontend (`extensions.js`)**:
```javascript
ILS.execTicketedRequest = function(config){
    // Step 1: Get Alfresco ticket
    Ext.Ajax.request({
        url: 'get.do',
        params: {h: 'alf', action: 'login'},
        callback: function(o, success, response){
            var json = Ext.util.JSON.decode(response.responseText);
            if (json && json.endpoint){
                var lrsUrl = json.endpoint.left(pos) + config.url;
                var ticket = json.ticket;
                
                // Step 2: Make authenticated request
                Ext.Ajax.request({
                    url: lrsUrl,
                    method: 'GET',
                    params: Ext.applyIf(config.params, {ticket: ticket}),
                    callback: function(o, success, response){
                        // Handle response
                        
                        // Step 3: Logout
                        Ext.Ajax.request({
                            url: 'get.do',
                            params: {h: 'alf', action: 'logout', ticket: ticket}
                        });
                    }
                });
            }
        }
    });
};
```

## Key Findings

### 1. **Aumentum Web Server**
- **URL**: `http://10.10.10.3:8080/lrswa/`
- **Framework**: Java (likely Spring MVC) with `.do` extension mapping
- **Frontend**: ExtJS 3.x

### 2. **Document Access Pattern**
```
document_number (BP3208)
    ↓ (via alf_node_properties)
alf_node.uuid
    ↓ (via documentPage.do)
Document Binary/PDF
```

### 3. **Alfresco Integration**
- Aumentum uses **Alfresco** as its content management system
- Authentication is **ticket-based**
- Endpoint is discovered dynamically via `/get.do?h=alf&action=login`

### 4. **Database vs Web Access**
Our current approach directly queries the database and filesystem. Aumentum's approach:
- **Uses web services** for content access
- **Authenticates via Alfresco**
- **Resolves UUIDs dynamically**

## How This Helps Our Implementation

### Current Approach (Direct DB + Filesystem)
```
document_number (BP3208)
    ↓ Query LRSAdmin.alf_node_properties
alf_node.uuid
    ↓ Query LRSAdmin.alf_content_url
store:// URL
    ↓ Parse to filesystem path
/mnt/contentstore/2014/12/18/16/20/e03a480a-f6ef-477f-b453-0d9d094dac16.bin
    ↓ Convert .bin to PDF
PDF response
```

✅ **Our approach is correct and matches Aumentum's data flow!**

### Improved Implementation

Based on these findings, we should:

1. **Add UUID-based lookup endpoint**:
```python
@app.get("/documents/by-uuid")
async def get_document_by_uuid(uuid: str):
    """Fetch document by Alfresco UUID directly"""
    pass
```

2. **Support both lookup methods**:
   - By `document_number` (our current implementation) ✅
   - By `uuid` (Aumentum's native method) ⚠️ Missing

3. **Consider Alfresco API integration** (optional):
   - Authenticate via Alfresco
   - Use native content APIs
   - More robust but requires Alfresco credentials

## Recommendations

### Immediate (Keep Current Approach)
✅ **Our current implementation is production-ready** for direct database access.

### Enhanced (Add UUID Support)
1. Add `/documents/by-uuid?uuid=<uuid>` endpoint
2. Query `alf_content_url` by joining `alf_node.uuid`
3. Return converted PDF

### Advanced (Alfresco Integration)
1. Integrate with Alfresco's REST API
2. Use ticket-based authentication
3. Leverage Alfresco's built-in conversion services
4. **Requires**: Alfresco credentials and endpoint discovery

## SQL Queries to Add

### Get Document by UUID
```sql
SELECT cu.content_url, cu.content_size, mt.mimetype_str
FROM LRSAdmin.alf_node n
JOIN LRSAdmin.alf_content_data cd ON cd.id = n.id
JOIN LRSAdmin.alf_content_url cu ON cu.id = cd.content_url_id
LEFT JOIN LRSAdmin.alf_mimetype mt ON mt.id = cd.content_mimetype_id
WHERE n.uuid = ? AND n.node_deleted = 0
```

### Get UUID from Document Number
```sql
SELECT n.uuid
FROM LRSAdmin.alf_node_properties np
JOIN LRSAdmin.alf_qname q ON q.id = np.qname_id
JOIN LRSAdmin.alf_node n ON n.id = np.node_id
WHERE np.string_value = ? 
  AND q.local_name IN ('targetRids','sourceRids')
  AND n.node_deleted = 0
```

## Conclusion

**Our implementation is aligned with Aumentum's architecture:**
- ✅ We query the same LRSAdmin schema
- ✅ We resolve `document_number` → `store://` → PDF
- ✅ We handle MSSQL correctly
- ✅ We convert .bin to PDF correctly

**Additional improvements available:**
- ⚠️ Add UUID-based lookup
- ⚠️ Integrate with Alfresco API (optional)
- ⚠️ Add ticket-based authentication (if needed)

**The application is ready for deployment** with the current database-direct approach. Alfresco integration is optional and can be added later if needed.

---

**Files Analyzed**:
- `Details_Document .html` - Main page structure
- `imgviewer.js` - Document URL generation
- `extensions.js` - Alfresco authentication flow
- `forms.js` - Search form handling
- `tabs.js` - Results tab management
- `utils.js` - Utility functions