Initial commit of Asset Lite app
This commit is contained in:
commit
8208384687
7
.gitignore
vendored
Normal file
7
.gitignore
vendored
Normal file
@ -0,0 +1,7 @@
|
||||
.DS_Store
|
||||
*.pyc
|
||||
*.egg-info
|
||||
*.swp
|
||||
tags
|
||||
node_modules
|
||||
__pycache__
|
||||
7
README.md
Normal file
7
README.md
Normal file
@ -0,0 +1,7 @@
|
||||
## Asset Lite
|
||||
|
||||
Asset Management System
|
||||
|
||||
#### License
|
||||
|
||||
mit
|
||||
1
asset_lite/__init__.py
Normal file
1
asset_lite/__init__.py
Normal file
@ -0,0 +1 @@
|
||||
__version__ = "0.0.1"
|
||||
1
asset_lite/api/__init__.py
Normal file
1
asset_lite/api/__init__.py
Normal file
@ -0,0 +1 @@
|
||||
from . import asset_api
|
||||
49
asset_lite/api/api.py
Normal file
49
asset_lite/api/api.py
Normal file
@ -0,0 +1,49 @@
|
||||
import frappe
|
||||
|
||||
@frappe.whitelist()
|
||||
def get_current_user_data():
|
||||
user = frappe.session.user
|
||||
|
||||
if user == "Guest":
|
||||
return None
|
||||
|
||||
user_doc = frappe.get_doc("User", user)
|
||||
|
||||
return {
|
||||
"email": user_doc.name,
|
||||
"full_name": user_doc.full_name,
|
||||
"user_image": user_doc.user_image,
|
||||
"role_profile_name": user_doc.role_profile_name,
|
||||
"roles": [d.role for d in user_doc.roles]
|
||||
}
|
||||
|
||||
|
||||
|
||||
def set_default_homepage():
|
||||
|
||||
"""
|
||||
Set the default workspace based on the user's role.
|
||||
"""
|
||||
# Get the current user
|
||||
current_user = frappe.session.user
|
||||
|
||||
# Skip for system users
|
||||
if current_user in ("Administrator", "Guest"):
|
||||
return
|
||||
|
||||
# Define role-based workspaces
|
||||
role_based_workspaces = {
|
||||
"Maintenance Manager": "asset-management",
|
||||
#"Maintenance User": "asset-management",
|
||||
#"Technician": "asset-management"
|
||||
}
|
||||
|
||||
# Get the user's roles
|
||||
user_roles = frappe.get_roles(current_user)
|
||||
|
||||
# Determine the default workspace
|
||||
for role, workspace in role_based_workspaces.items():
|
||||
if role in user_roles:
|
||||
# Set the session home page
|
||||
frappe.local.response["home_page"] = f"/app/{workspace}"
|
||||
return
|
||||
1165
asset_lite/api/asset_api.py
Normal file
1165
asset_lite/api/asset_api.py
Normal file
File diff suppressed because it is too large
Load Diff
712
asset_lite/api/asset_maintenance_api.py
Normal file
712
asset_lite/api/asset_maintenance_api.py
Normal file
@ -0,0 +1,712 @@
|
||||
import frappe
|
||||
from frappe import _
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def get_asset_maintenance_logs(filters=None, fields=None, limit=20, offset=0, order_by=None, include_child_tables=False):
|
||||
"""
|
||||
Get list of asset maintenance logs with filters and pagination
|
||||
|
||||
Args:
|
||||
filters: JSON string of filters (e.g., '{"maintenance_status": "Planned"}')
|
||||
fields: JSON string of fields to return (e.g., '["asset_name", "due_date"]')
|
||||
limit: Number of records to return (default: 20)
|
||||
offset: Number of records to skip (default: 0)
|
||||
order_by: Sort order (e.g., "creation desc")
|
||||
include_child_tables: Whether to include child table data (default: False)
|
||||
|
||||
Returns:
|
||||
{
|
||||
"asset_maintenance_logs": [...],
|
||||
"total_count": int,
|
||||
"limit": int,
|
||||
"offset": int,
|
||||
"has_more": bool
|
||||
}
|
||||
"""
|
||||
try:
|
||||
import json
|
||||
|
||||
# Parse filters if provided
|
||||
if filters and isinstance(filters, str):
|
||||
filters = json.loads(filters)
|
||||
|
||||
# Parse fields if provided
|
||||
if fields and isinstance(fields, str):
|
||||
fields = json.loads(fields)
|
||||
else:
|
||||
# Default fields to return
|
||||
fields = [
|
||||
'name',
|
||||
'asset_maintenance',
|
||||
'naming_series',
|
||||
'asset_name',
|
||||
'custom_asset_type',
|
||||
'item_code',
|
||||
'item_name',
|
||||
'custom_asset_names',
|
||||
'custom_hospital_name',
|
||||
'task',
|
||||
'task_name',
|
||||
'maintenance_type',
|
||||
'periodicity',
|
||||
'has_certificate',
|
||||
'custom_early_completion',
|
||||
'maintenance_status',
|
||||
'custom_pm_overdue_reason',
|
||||
'custom_accepted_by_moh',
|
||||
'assign_to_name',
|
||||
'due_date',
|
||||
'completion_date',
|
||||
'custom_early_completion_reason',
|
||||
'custom_accepted_by_moh_',
|
||||
'custom_template',
|
||||
'workflow_state',
|
||||
'creation',
|
||||
'modified',
|
||||
'owner',
|
||||
'modified_by',
|
||||
'docstatus',
|
||||
'idx'
|
||||
]
|
||||
|
||||
# Get total count
|
||||
total_count = frappe.db.count('Asset Maintenance Log', filters=filters or {})
|
||||
|
||||
# Get asset maintenance logs
|
||||
asset_maintenance_logs = frappe.get_all(
|
||||
'Asset Maintenance Log',
|
||||
filters=filters or {},
|
||||
fields=fields,
|
||||
limit_page_length=int(limit),
|
||||
limit_start=int(offset),
|
||||
order_by=order_by or 'creation desc'
|
||||
)
|
||||
|
||||
# Include child tables if requested
|
||||
if include_child_tables and include_child_tables != 'false':
|
||||
for log in asset_maintenance_logs:
|
||||
log['custom_table'] = frappe.get_all(
|
||||
'PPM Table',
|
||||
filters={'parent': log['name']},
|
||||
fields=['name', 'idx', 'maintenance_name', 'working', 'defect_found', 'not_working'],
|
||||
order_by='idx asc'
|
||||
)
|
||||
|
||||
# Calculate has_more
|
||||
has_more = (int(offset) + int(limit)) < total_count
|
||||
|
||||
frappe.response['message'] = {
|
||||
'asset_maintenance_logs': asset_maintenance_logs,
|
||||
'total_count': total_count,
|
||||
'limit': int(limit),
|
||||
'offset': int(offset),
|
||||
'has_more': has_more
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
frappe.log_error(frappe.get_traceback(), 'Get Asset Maintenance Logs API Error')
|
||||
frappe.response['message'] = {
|
||||
'error': str(e),
|
||||
'asset_maintenance_logs': [],
|
||||
'total_count': 0
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def get_asset_maintenance_log_details(log_name, include_child_tables=True):
|
||||
"""
|
||||
Get detailed information about a specific asset maintenance log
|
||||
|
||||
Args:
|
||||
log_name: Name/ID of the asset maintenance log
|
||||
include_child_tables: Whether to include child table data (default: True)
|
||||
|
||||
Returns:
|
||||
Asset Maintenance Log document with all fields including child tables
|
||||
"""
|
||||
try:
|
||||
if not log_name:
|
||||
frappe.throw(_('Asset Maintenance Log name is required'))
|
||||
|
||||
# Check if user has permission to read this log
|
||||
if not frappe.has_permission('Asset Maintenance Log', 'read', log_name):
|
||||
frappe.throw(_('Not permitted to access this asset maintenance log'))
|
||||
|
||||
# Get asset maintenance log details
|
||||
log = frappe.get_doc('Asset Maintenance Log', log_name)
|
||||
|
||||
frappe.response['message'] = log.as_dict()
|
||||
|
||||
except Exception as e:
|
||||
frappe.log_error(frappe.get_traceback(), 'Get Asset Maintenance Log Details API Error')
|
||||
frappe.response['message'] = {
|
||||
'error': str(e)
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def create_asset_maintenance_log(log_data):
|
||||
"""
|
||||
Create a new asset maintenance log
|
||||
|
||||
Args:
|
||||
log_data: JSON string containing asset maintenance log fields
|
||||
|
||||
Returns:
|
||||
Created asset maintenance log document
|
||||
"""
|
||||
try:
|
||||
import json
|
||||
|
||||
# Parse log data
|
||||
if isinstance(log_data, str):
|
||||
log_data = json.loads(log_data)
|
||||
|
||||
# Check if user has permission to create asset maintenance log
|
||||
if not frappe.has_permission('Asset Maintenance Log', 'create'):
|
||||
frappe.throw(_('Not permitted to create asset maintenance log'))
|
||||
|
||||
# Extract child table data
|
||||
custom_table_data = log_data.pop('custom_table', [])
|
||||
|
||||
# Create new asset maintenance log
|
||||
log = frappe.get_doc({
|
||||
'doctype': 'Asset Maintenance Log',
|
||||
**log_data
|
||||
})
|
||||
|
||||
# Add child table rows
|
||||
if custom_table_data:
|
||||
for row_data in custom_table_data:
|
||||
log.append('custom_table', {
|
||||
'maintenance_name': row_data.get('maintenance_name', ''),
|
||||
'working': row_data.get('working', 0),
|
||||
'defect_found': row_data.get('defect_found', 0),
|
||||
'not_working': row_data.get('not_working', 0)
|
||||
})
|
||||
|
||||
log.insert()
|
||||
frappe.db.commit()
|
||||
|
||||
frappe.response['message'] = {
|
||||
'success': True,
|
||||
'asset_maintenance_log': log.as_dict(),
|
||||
'message': _('Asset Maintenance Log created successfully')
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
frappe.db.rollback()
|
||||
frappe.log_error(frappe.get_traceback(), 'Create Asset Maintenance Log API Error')
|
||||
frappe.response['message'] = {
|
||||
'success': False,
|
||||
'error': str(e)
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def update_asset_maintenance_log(log_name, log_data):
|
||||
"""
|
||||
Update an existing asset maintenance log
|
||||
|
||||
Args:
|
||||
log_name: Name/ID of the asset maintenance log
|
||||
log_data: JSON string containing fields to update
|
||||
|
||||
Returns:
|
||||
Updated asset maintenance log document
|
||||
"""
|
||||
try:
|
||||
import json
|
||||
|
||||
if not log_name:
|
||||
frappe.throw(_('Asset Maintenance Log name is required'))
|
||||
|
||||
# Parse log data
|
||||
if isinstance(log_data, str):
|
||||
log_data = json.loads(log_data)
|
||||
|
||||
# Check if user has permission to update this log
|
||||
if not frappe.has_permission('Asset Maintenance Log', 'write', log_name):
|
||||
frappe.throw(_('Not permitted to update this asset maintenance log'))
|
||||
|
||||
# Get asset maintenance log
|
||||
log = frappe.get_doc('Asset Maintenance Log', log_name)
|
||||
|
||||
# Extract child table data before processing other fields
|
||||
custom_table_data = log_data.pop('custom_table', None)
|
||||
|
||||
# List of child table fields to skip in regular update
|
||||
child_table_fields = ['custom_table', 'table']
|
||||
|
||||
# Update regular fields (not child tables)
|
||||
for key, value in log_data.items():
|
||||
if key not in child_table_fields and hasattr(log, key):
|
||||
setattr(log, key, value)
|
||||
|
||||
# Handle child table update if provided
|
||||
if custom_table_data is not None:
|
||||
# Clear existing child table rows
|
||||
log.custom_table = []
|
||||
|
||||
# Add new child table rows
|
||||
for row_data in custom_table_data:
|
||||
log.append('custom_table', {
|
||||
'maintenance_name': row_data.get('maintenance_name', ''),
|
||||
'working': row_data.get('working', 0),
|
||||
'defect_found': row_data.get('defect_found', 0),
|
||||
'not_working': row_data.get('not_working', 0)
|
||||
})
|
||||
|
||||
log.save()
|
||||
frappe.db.commit()
|
||||
|
||||
frappe.response['message'] = {
|
||||
'success': True,
|
||||
'asset_maintenance_log': log.as_dict(),
|
||||
'message': _('Asset Maintenance Log updated successfully')
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
frappe.db.rollback()
|
||||
frappe.log_error(frappe.get_traceback(), 'Update Asset Maintenance Log API Error')
|
||||
frappe.response['message'] = {
|
||||
'success': False,
|
||||
'error': str(e)
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def delete_asset_maintenance_log(log_name):
|
||||
"""
|
||||
Delete an asset maintenance log
|
||||
|
||||
Args:
|
||||
log_name: Name/ID of the asset maintenance log
|
||||
|
||||
Returns:
|
||||
Success message
|
||||
"""
|
||||
try:
|
||||
if not log_name:
|
||||
frappe.throw(_('Asset Maintenance Log name is required'))
|
||||
|
||||
# Check if user has permission to delete this log
|
||||
if not frappe.has_permission('Asset Maintenance Log', 'delete', log_name):
|
||||
frappe.throw(_('Not permitted to delete this asset maintenance log'))
|
||||
|
||||
# Delete asset maintenance log
|
||||
frappe.delete_doc('Asset Maintenance Log', log_name)
|
||||
frappe.db.commit()
|
||||
|
||||
frappe.response['message'] = {
|
||||
'success': True,
|
||||
'message': _('Asset Maintenance Log deleted successfully')
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
frappe.db.rollback()
|
||||
frappe.log_error(frappe.get_traceback(), 'Delete Asset Maintenance Log API Error')
|
||||
frappe.response['message'] = {
|
||||
'success': False,
|
||||
'error': str(e)
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def update_maintenance_status(log_name, maintenance_status=None, workflow_state=None):
|
||||
"""
|
||||
Update asset maintenance log status
|
||||
|
||||
Args:
|
||||
log_name: Name/ID of the asset maintenance log
|
||||
maintenance_status: New maintenance status (e.g., 'Planned', 'Completed', 'Overdue')
|
||||
workflow_state: New workflow state
|
||||
|
||||
Returns:
|
||||
Updated asset maintenance log document
|
||||
"""
|
||||
try:
|
||||
if not log_name:
|
||||
frappe.throw(_('Asset Maintenance Log name is required'))
|
||||
|
||||
# Check if user has permission to update this log
|
||||
if not frappe.has_permission('Asset Maintenance Log', 'write', log_name):
|
||||
frappe.throw(_('Not permitted to update this asset maintenance log'))
|
||||
|
||||
# Get asset maintenance log
|
||||
log = frappe.get_doc('Asset Maintenance Log', log_name)
|
||||
|
||||
# Update status fields
|
||||
if maintenance_status:
|
||||
log.maintenance_status = maintenance_status
|
||||
|
||||
if workflow_state:
|
||||
log.workflow_state = workflow_state
|
||||
|
||||
log.save()
|
||||
frappe.db.commit()
|
||||
|
||||
frappe.response['message'] = {
|
||||
'success': True,
|
||||
'asset_maintenance_log': log.as_dict(),
|
||||
'message': _('Asset Maintenance Log status updated successfully')
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
frappe.db.rollback()
|
||||
frappe.log_error(frappe.get_traceback(), 'Update Maintenance Status API Error')
|
||||
frappe.response['message'] = {
|
||||
'success': False,
|
||||
'error': str(e)
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def get_maintenance_logs_by_asset(asset_name, filters=None, limit=20, offset=0, include_child_tables=False):
|
||||
"""
|
||||
Get all maintenance logs for a specific asset
|
||||
|
||||
Args:
|
||||
asset_name: Name/ID of the asset
|
||||
filters: Additional JSON string of filters
|
||||
limit: Number of records to return (default: 20)
|
||||
offset: Number of records to skip (default: 0)
|
||||
include_child_tables: Whether to include child table data (default: False)
|
||||
|
||||
Returns:
|
||||
List of maintenance logs for the asset
|
||||
"""
|
||||
try:
|
||||
import json
|
||||
|
||||
if not asset_name:
|
||||
frappe.throw(_('Asset name is required'))
|
||||
|
||||
# Parse additional filters if provided
|
||||
additional_filters = {}
|
||||
if filters and isinstance(filters, str):
|
||||
additional_filters = json.loads(filters)
|
||||
|
||||
# Combine filters
|
||||
combined_filters = {'asset_name': asset_name, **additional_filters}
|
||||
|
||||
# Get total count
|
||||
total_count = frappe.db.count('Asset Maintenance Log', filters=combined_filters)
|
||||
|
||||
# Get maintenance logs
|
||||
logs = frappe.get_all(
|
||||
'Asset Maintenance Log',
|
||||
filters=combined_filters,
|
||||
fields=['*'],
|
||||
limit_page_length=int(limit),
|
||||
limit_start=int(offset),
|
||||
order_by='due_date desc'
|
||||
)
|
||||
|
||||
# Include child tables if requested
|
||||
if include_child_tables and include_child_tables != 'false':
|
||||
for log in logs:
|
||||
log['custom_table'] = frappe.get_all(
|
||||
'PPM Table',
|
||||
filters={'parent': log['name']},
|
||||
fields=['name', 'idx', 'maintenance_name', 'working', 'defect_found', 'not_working'],
|
||||
order_by='idx asc'
|
||||
)
|
||||
|
||||
# Calculate has_more
|
||||
has_more = (int(offset) + int(limit)) < total_count
|
||||
|
||||
frappe.response['message'] = {
|
||||
'asset_maintenance_logs': logs,
|
||||
'total_count': total_count,
|
||||
'limit': int(limit),
|
||||
'offset': int(offset),
|
||||
'has_more': has_more
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
frappe.log_error(frappe.get_traceback(), 'Get Maintenance Logs By Asset API Error')
|
||||
frappe.response['message'] = {
|
||||
'error': str(e),
|
||||
'asset_maintenance_logs': [],
|
||||
'total_count': 0
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def get_overdue_maintenance_logs(filters=None, limit=20, offset=0, include_child_tables=False):
|
||||
"""
|
||||
Get all overdue maintenance logs
|
||||
|
||||
Args:
|
||||
filters: Additional JSON string of filters
|
||||
limit: Number of records to return (default: 20)
|
||||
offset: Number of records to skip (default: 0)
|
||||
include_child_tables: Whether to include child table data (default: False)
|
||||
|
||||
Returns:
|
||||
List of overdue maintenance logs
|
||||
"""
|
||||
try:
|
||||
import json
|
||||
from frappe.utils import today
|
||||
|
||||
# Parse additional filters if provided
|
||||
additional_filters = {}
|
||||
if filters and isinstance(filters, str):
|
||||
additional_filters = json.loads(filters)
|
||||
|
||||
# Combine filters - get logs with due_date less than today and status not completed
|
||||
combined_filters = {
|
||||
'due_date': ['<', today()],
|
||||
'maintenance_status': ['!=', 'Completed'],
|
||||
**additional_filters
|
||||
}
|
||||
|
||||
# Get total count
|
||||
total_count = frappe.db.count('Asset Maintenance Log', filters=combined_filters)
|
||||
|
||||
# Get overdue logs
|
||||
logs = frappe.get_all(
|
||||
'Asset Maintenance Log',
|
||||
filters=combined_filters,
|
||||
fields=['*'],
|
||||
limit_page_length=int(limit),
|
||||
limit_start=int(offset),
|
||||
order_by='due_date asc'
|
||||
)
|
||||
|
||||
# Include child tables if requested
|
||||
if include_child_tables and include_child_tables != 'false':
|
||||
for log in logs:
|
||||
log['custom_table'] = frappe.get_all(
|
||||
'PPM Table',
|
||||
filters={'parent': log['name']},
|
||||
fields=['name', 'idx', 'maintenance_name', 'working', 'defect_found', 'not_working'],
|
||||
order_by='idx asc'
|
||||
)
|
||||
|
||||
# Calculate has_more
|
||||
has_more = (int(offset) + int(limit)) < total_count
|
||||
|
||||
frappe.response['message'] = {
|
||||
'asset_maintenance_logs': logs,
|
||||
'total_count': total_count,
|
||||
'limit': int(limit),
|
||||
'offset': int(offset),
|
||||
'has_more': has_more
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
frappe.log_error(frappe.get_traceback(), 'Get Overdue Maintenance Logs API Error')
|
||||
frappe.response['message'] = {
|
||||
'error': str(e),
|
||||
'asset_maintenance_logs': [],
|
||||
'total_count': 0
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def add_ppm_table_row(log_name, row_data):
|
||||
"""
|
||||
Add a PPM table row to a maintenance log
|
||||
|
||||
Args:
|
||||
log_name: Name/ID of the asset maintenance log
|
||||
row_data: JSON string containing row fields
|
||||
|
||||
Returns:
|
||||
Updated custom_table array
|
||||
"""
|
||||
try:
|
||||
import json
|
||||
|
||||
if not log_name:
|
||||
frappe.throw(_('Asset Maintenance Log name is required'))
|
||||
|
||||
# Parse row data
|
||||
if isinstance(row_data, str):
|
||||
row_data = json.loads(row_data)
|
||||
|
||||
# Check permission
|
||||
if not frappe.has_permission('Asset Maintenance Log', 'write', log_name):
|
||||
frappe.throw(_('Not permitted to update this asset maintenance log'))
|
||||
|
||||
# Get log and add row
|
||||
log = frappe.get_doc('Asset Maintenance Log', log_name)
|
||||
log.append('custom_table', {
|
||||
'maintenance_name': row_data.get('maintenance_name', ''),
|
||||
'working': row_data.get('working', 0),
|
||||
'defect_found': row_data.get('defect_found', 0),
|
||||
'not_working': row_data.get('not_working', 0)
|
||||
})
|
||||
|
||||
log.save()
|
||||
frappe.db.commit()
|
||||
|
||||
# Return updated child table
|
||||
custom_table = []
|
||||
for row in log.custom_table:
|
||||
custom_table.append({
|
||||
'name': row.name,
|
||||
'idx': row.idx,
|
||||
'maintenance_name': row.maintenance_name,
|
||||
'working': row.working,
|
||||
'defect_found': row.defect_found,
|
||||
'not_working': row.not_working
|
||||
})
|
||||
|
||||
frappe.response['message'] = {
|
||||
'success': True,
|
||||
'custom_table': custom_table,
|
||||
'message': _('PPM table row added successfully')
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
frappe.db.rollback()
|
||||
frappe.log_error(frappe.get_traceback(), 'Add PPM Table Row API Error')
|
||||
frappe.response['message'] = {
|
||||
'success': False,
|
||||
'error': str(e)
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def remove_ppm_table_row(log_name, row_name):
|
||||
"""
|
||||
Remove a PPM table row from a maintenance log
|
||||
|
||||
Args:
|
||||
log_name: Name/ID of the asset maintenance log
|
||||
row_name: Name/ID of the row to remove
|
||||
|
||||
Returns:
|
||||
Updated custom_table array
|
||||
"""
|
||||
try:
|
||||
if not log_name:
|
||||
frappe.throw(_('Asset Maintenance Log name is required'))
|
||||
|
||||
if not row_name:
|
||||
frappe.throw(_('Row name is required'))
|
||||
|
||||
# Check permission
|
||||
if not frappe.has_permission('Asset Maintenance Log', 'write', log_name):
|
||||
frappe.throw(_('Not permitted to update this asset maintenance log'))
|
||||
|
||||
# Get log and remove row
|
||||
log = frappe.get_doc('Asset Maintenance Log', log_name)
|
||||
|
||||
# Find and remove the row
|
||||
row_to_remove = None
|
||||
for row in log.custom_table:
|
||||
if row.name == row_name:
|
||||
row_to_remove = row
|
||||
break
|
||||
|
||||
if row_to_remove:
|
||||
log.remove(row_to_remove)
|
||||
log.save()
|
||||
frappe.db.commit()
|
||||
|
||||
# Return updated child table
|
||||
custom_table = []
|
||||
for row in log.custom_table:
|
||||
custom_table.append({
|
||||
'name': row.name,
|
||||
'idx': row.idx,
|
||||
'maintenance_name': row.maintenance_name,
|
||||
'working': row.working,
|
||||
'defect_found': row.defect_found,
|
||||
'not_working': row.not_working
|
||||
})
|
||||
|
||||
frappe.response['message'] = {
|
||||
'success': True,
|
||||
'custom_table': custom_table,
|
||||
'message': _('PPM table row removed successfully')
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
frappe.db.rollback()
|
||||
frappe.log_error(frappe.get_traceback(), 'Remove PPM Table Row API Error')
|
||||
frappe.response['message'] = {
|
||||
'success': False,
|
||||
'error': str(e)
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def update_ppm_table_row(log_name, row_name, row_data):
|
||||
"""
|
||||
Update a PPM table row in a maintenance log
|
||||
|
||||
Args:
|
||||
log_name: Name/ID of the asset maintenance log
|
||||
row_name: Name/ID of the row to update
|
||||
row_data: JSON string containing fields to update
|
||||
|
||||
Returns:
|
||||
Updated custom_table array
|
||||
"""
|
||||
try:
|
||||
import json
|
||||
|
||||
if not log_name:
|
||||
frappe.throw(_('Asset Maintenance Log name is required'))
|
||||
|
||||
if not row_name:
|
||||
frappe.throw(_('Row name is required'))
|
||||
|
||||
# Parse row data
|
||||
if isinstance(row_data, str):
|
||||
row_data = json.loads(row_data)
|
||||
|
||||
# Check permission
|
||||
if not frappe.has_permission('Asset Maintenance Log', 'write', log_name):
|
||||
frappe.throw(_('Not permitted to update this asset maintenance log'))
|
||||
|
||||
# Get log and update row
|
||||
log = frappe.get_doc('Asset Maintenance Log', log_name)
|
||||
|
||||
# Find and update the row
|
||||
for row in log.custom_table:
|
||||
if row.name == row_name:
|
||||
if 'maintenance_name' in row_data:
|
||||
row.maintenance_name = row_data['maintenance_name']
|
||||
if 'working' in row_data:
|
||||
row.working = row_data['working']
|
||||
if 'defect_found' in row_data:
|
||||
row.defect_found = row_data['defect_found']
|
||||
if 'not_working' in row_data:
|
||||
row.not_working = row_data['not_working']
|
||||
break
|
||||
|
||||
log.save()
|
||||
frappe.db.commit()
|
||||
|
||||
# Return updated child table
|
||||
custom_table = []
|
||||
for row in log.custom_table:
|
||||
custom_table.append({
|
||||
'name': row.name,
|
||||
'idx': row.idx,
|
||||
'maintenance_name': row.maintenance_name,
|
||||
'working': row.working,
|
||||
'defect_found': row.defect_found,
|
||||
'not_working': row.not_working
|
||||
})
|
||||
|
||||
frappe.response['message'] = {
|
||||
'success': True,
|
||||
'custom_table': custom_table,
|
||||
'message': _('PPM table row updated successfully')
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
frappe.db.rollback()
|
||||
frappe.log_error(frappe.get_traceback(), 'Update PPM Table Row API Error')
|
||||
frappe.response['message'] = {
|
||||
'success': False,
|
||||
'error': str(e)
|
||||
}
|
||||
163
asset_lite/api/custom_api.py
Normal file
163
asset_lite/api/custom_api.py
Normal file
@ -0,0 +1,163 @@
|
||||
import frappe
|
||||
from frappe import _
|
||||
from frappe.utils import now, today, get_datetime
|
||||
import json
|
||||
|
||||
@frappe.whitelist(allow_guest=False)
|
||||
def get_user_details(user_id=None):
|
||||
"""
|
||||
Get detailed user information
|
||||
Usage: /api/method/asset_lite.api.custom_api.get_user_details
|
||||
"""
|
||||
try:
|
||||
if not user_id:
|
||||
user_id = frappe.session.user
|
||||
|
||||
user = frappe.get_doc("User", user_id)
|
||||
|
||||
# Get user roles
|
||||
roles = frappe.get_roles(user_id)
|
||||
|
||||
response_data = {
|
||||
"user_id": user_id,
|
||||
"full_name": user.full_name,
|
||||
"email": user.email,
|
||||
"user_image": user.user_image,
|
||||
"roles": roles,
|
||||
"last_login": user.last_login,
|
||||
"enabled": user.enabled,
|
||||
"creation": user.creation,
|
||||
"modified": user.modified
|
||||
}
|
||||
|
||||
frappe.response.message = response_data
|
||||
frappe.response.status_code = 200
|
||||
|
||||
except Exception as e:
|
||||
frappe.log_error(f"Error in get_user_details: {str(e)}")
|
||||
frappe.response.message = {"error": str(e)}
|
||||
frappe.response.status_code = 500
|
||||
|
||||
@frappe.whitelist(allow_guest=False)
|
||||
def get_doctype_records(doctype, filters=None, fields=None, limit=20, offset=0):
|
||||
"""
|
||||
Get records from any DocType with filtering and pagination
|
||||
Usage: /api/method/asset_lite.api.custom_api.get_doctype_records
|
||||
"""
|
||||
try:
|
||||
# Parse filters and fields if provided as JSON strings
|
||||
if isinstance(filters, str):
|
||||
filters = json.loads(filters)
|
||||
if isinstance(fields, str):
|
||||
fields = json.loads(fields)
|
||||
|
||||
# Build the query
|
||||
query_filters = filters or {}
|
||||
|
||||
# Get records
|
||||
records = frappe.get_list(
|
||||
doctype,
|
||||
filters=query_filters,
|
||||
fields=fields or ["*"],
|
||||
limit=limit,
|
||||
start=offset,
|
||||
order_by="creation desc"
|
||||
)
|
||||
|
||||
# Get total count for pagination
|
||||
total_count = frappe.db.count(doctype, query_filters)
|
||||
|
||||
response_data = {
|
||||
"records": records,
|
||||
"total_count": total_count,
|
||||
"limit": limit,
|
||||
"offset": offset,
|
||||
"has_more": (offset + limit) < total_count
|
||||
}
|
||||
|
||||
frappe.response.message = response_data
|
||||
frappe.response.status_code = 200
|
||||
|
||||
except Exception as e:
|
||||
frappe.log_error(f"Error in get_doctype_records: {str(e)}")
|
||||
frappe.response.message = {"error": str(e)}
|
||||
frappe.response.status_code = 500
|
||||
|
||||
@frappe.whitelist(allow_guest=False)
|
||||
def get_dashboard_stats():
|
||||
"""
|
||||
Get dashboard statistics
|
||||
Usage: /api/method/asset_lite.api.custom_api.get_dashboard_stats
|
||||
"""
|
||||
try:
|
||||
# Example: Get counts for different DocTypes
|
||||
stats = {
|
||||
"total_users": frappe.db.count("User", {"enabled": 1}),
|
||||
"total_customers": frappe.db.count("Customer"),
|
||||
"total_items": frappe.db.count("Item"),
|
||||
"total_orders": frappe.db.count("Sales Order"),
|
||||
"recent_activities": []
|
||||
}
|
||||
|
||||
# Get recent activities (example)
|
||||
recent_users = frappe.get_list(
|
||||
"User",
|
||||
fields=["name", "full_name", "creation"],
|
||||
limit=5,
|
||||
order_by="creation desc"
|
||||
)
|
||||
|
||||
stats["recent_activities"] = recent_users
|
||||
|
||||
frappe.response.message = stats
|
||||
frappe.response.status_code = 200
|
||||
|
||||
except Exception as e:
|
||||
frappe.log_error(f"Error in get_dashboard_stats: {str(e)}")
|
||||
frappe.response.message = {"error": str(e)}
|
||||
frappe.response.status_code = 500
|
||||
|
||||
# Example KYC API for your KYCDetails component
|
||||
@frappe.whitelist(allow_guest=False)
|
||||
def get_kyc_details():
|
||||
"""
|
||||
Get KYC details - customize this based on your actual KYC DocType
|
||||
Usage: /api/method/asset_lite.api.custom_api.get_kyc_details
|
||||
"""
|
||||
try:
|
||||
# Replace 'KYC' with your actual DocType name
|
||||
kyc_records = frappe.get_list(
|
||||
"KYC", # Change this to your actual DocType
|
||||
fields=["name", "kyc_status", "kyc_type", "creation"],
|
||||
limit=50,
|
||||
order_by="creation desc"
|
||||
)
|
||||
|
||||
frappe.response.message = kyc_records
|
||||
frappe.response.status_code = 200
|
||||
|
||||
except Exception as e:
|
||||
frappe.log_error(f"Error in get_kyc_details: {str(e)}")
|
||||
frappe.response.message = {"error": str(e)}
|
||||
frappe.response.status_code = 500
|
||||
|
||||
# Simple test endpoint to verify API is working
|
||||
@frappe.whitelist(allow_guest=False)
|
||||
def test_api():
|
||||
"""
|
||||
Simple test endpoint to verify the API is working
|
||||
Usage: /api/method/asset_lite.api.custom_api.test_api
|
||||
"""
|
||||
try:
|
||||
frappe.response.message = {
|
||||
"status": "success",
|
||||
"message": "API is working!",
|
||||
"user": frappe.session.user,
|
||||
"timestamp": now()
|
||||
}
|
||||
frappe.response.status_code = 200
|
||||
|
||||
except Exception as e:
|
||||
frappe.log_error(f"Error in test_api: {str(e)}")
|
||||
frappe.response.message = {"error": str(e)}
|
||||
frappe.response.status_code = 500
|
||||
1031
asset_lite/api/dashboard_api.py
Normal file
1031
asset_lite/api/dashboard_api.py
Normal file
File diff suppressed because it is too large
Load Diff
121
asset_lite/api/data_import_api.py
Normal file
121
asset_lite/api/data_import_api.py
Normal file
@ -0,0 +1,121 @@
|
||||
import csv
|
||||
import os
|
||||
from io import StringIO
|
||||
|
||||
import frappe
|
||||
from frappe import _
|
||||
from frappe.utils.csvutils import read_csv_content
|
||||
from frappe.utils.file_manager import save_file
|
||||
from frappe.utils.xlsxutils import (
|
||||
make_xlsx,
|
||||
read_xls_file_from_attached_file,
|
||||
read_xlsx_file_from_attached_file,
|
||||
)
|
||||
|
||||
|
||||
def _trim_cell(value):
|
||||
if isinstance(value, str):
|
||||
trimmed = value.strip()
|
||||
return trimmed if trimmed else None
|
||||
return value
|
||||
|
||||
|
||||
def _trim_rows(rows):
|
||||
trimmed_cells = 0
|
||||
out = []
|
||||
for row in rows:
|
||||
new_row = []
|
||||
for cell in row:
|
||||
if isinstance(cell, str):
|
||||
original = cell
|
||||
trimmed = _trim_cell(cell)
|
||||
if original != (trimmed or ""):
|
||||
trimmed_cells += 1
|
||||
new_row.append(trimmed)
|
||||
else:
|
||||
new_row.append(cell)
|
||||
out.append(new_row)
|
||||
return out, trimmed_cells
|
||||
|
||||
|
||||
def _read_rows_from_content(content, extension):
|
||||
extension = (extension or "").lower()
|
||||
if extension == "csv":
|
||||
return read_csv_content(content)
|
||||
if extension == "xlsx":
|
||||
return read_xlsx_file_from_attached_file(fcontent=content)
|
||||
if extension == "xls":
|
||||
return read_xls_file_from_attached_file(content)
|
||||
frappe.throw(_("Import file must be .csv, .xlsx, or .xls"))
|
||||
|
||||
|
||||
def _write_trimmed_content(rows, extension):
|
||||
extension = (extension or "").lower()
|
||||
if extension == "csv":
|
||||
buffer = StringIO()
|
||||
writer = csv.writer(buffer)
|
||||
for row in rows:
|
||||
writer.writerow(["" if cell is None else cell for cell in row])
|
||||
return buffer.getvalue().encode("utf-8"), "csv"
|
||||
|
||||
if extension == "xls":
|
||||
extension = "xlsx"
|
||||
|
||||
if extension == "xlsx":
|
||||
return make_xlsx(rows, "Import").getvalue(), "xlsx"
|
||||
|
||||
frappe.throw(_("Import file must be .csv, .xlsx, or .xls"))
|
||||
|
||||
|
||||
def _trimmed_filename(original_name, output_extension):
|
||||
base, _ = os.path.splitext(original_name or "import")
|
||||
return f"{base}_trimmed.{output_extension}"
|
||||
|
||||
|
||||
@frappe.whitelist()
|
||||
def trim_and_upload_import_file(data_import):
|
||||
doc = frappe.get_doc("Data Import", data_import)
|
||||
doc.check_permission("write")
|
||||
|
||||
if not doc.import_file:
|
||||
frappe.throw(_("Attach an import file first."))
|
||||
|
||||
if doc.google_sheets_url:
|
||||
frappe.throw(_("Trim and Upload is only available for attached files, not Google Sheets URLs."))
|
||||
|
||||
file_name = frappe.db.get_value("File", {"file_url": doc.import_file}, "name")
|
||||
if not file_name:
|
||||
frappe.throw(_("Import file not found in File attachments."))
|
||||
|
||||
source_file = frappe.get_doc("File", file_name)
|
||||
content = source_file.get_content()
|
||||
extension = os.path.splitext(source_file.file_name or doc.import_file)[1][1:].lower()
|
||||
|
||||
rows = _read_rows_from_content(content, extension)
|
||||
if not rows:
|
||||
frappe.throw(_("Import file is empty."))
|
||||
|
||||
trimmed_rows, trimmed_cells = _trim_rows(rows)
|
||||
output_content, output_extension = _write_trimmed_content(trimmed_rows, extension)
|
||||
output_name = _trimmed_filename(source_file.file_name or os.path.basename(doc.import_file), output_extension)
|
||||
|
||||
new_file = save_file(
|
||||
output_name,
|
||||
output_content,
|
||||
dt=doc.doctype,
|
||||
dn=doc.name,
|
||||
is_private=source_file.is_private,
|
||||
df="import_file",
|
||||
)
|
||||
|
||||
doc.import_file = new_file.file_url
|
||||
doc.template_options = ""
|
||||
doc.template_warnings = ""
|
||||
doc.save()
|
||||
|
||||
return {
|
||||
"import_file": new_file.file_url,
|
||||
"file_name": new_file.file_name,
|
||||
"trimmed_cells": trimmed_cells,
|
||||
"summary": _("Trimmed {0} cell(s) and uploaded {1}.").format(trimmed_cells, new_file.file_name),
|
||||
}
|
||||
128
asset_lite/api/delete_asset.py
Normal file
128
asset_lite/api/delete_asset.py
Normal file
@ -0,0 +1,128 @@
|
||||
import frappe
|
||||
from frappe import _
|
||||
|
||||
|
||||
def _cancel_and_delete(doctype: str, name: str) -> None:
|
||||
doc = frappe.get_doc(doctype, name)
|
||||
doc.flags.ignore_permissions = True
|
||||
doc.flags.ignore_links = True
|
||||
if doc.docstatus == 1:
|
||||
doc.cancel()
|
||||
frappe.db.commit()
|
||||
frappe.delete_doc(doctype, name, force=True, ignore_permissions=True, ignore_on_trash=True)
|
||||
frappe.db.commit()
|
||||
|
||||
|
||||
def _safe_collect(fn, *args) -> dict:
|
||||
results = {"deleted": [], "errors": []}
|
||||
try:
|
||||
results["deleted"] = fn(*args)
|
||||
except Exception as e:
|
||||
results["errors"].append(str(e))
|
||||
return results
|
||||
|
||||
|
||||
def _del_asset_activities(asset_name: str) -> list:
|
||||
deleted = []
|
||||
for name in frappe.get_all("Asset Activity", filters={"asset": asset_name}, pluck="name"):
|
||||
try:
|
||||
frappe.delete_doc("Asset Activity", name, force=True, ignore_permissions=True, ignore_on_trash=True)
|
||||
frappe.db.commit()
|
||||
deleted.append(name)
|
||||
except Exception as e:
|
||||
frappe.log_error(f"Asset Activity delete error [{name}]: {e}")
|
||||
return deleted
|
||||
|
||||
|
||||
def _del_asset_movements(asset_name: str) -> list:
|
||||
deleted = []
|
||||
parent_names = list(set(
|
||||
frappe.get_all("Asset Movement Item", filters={"asset": asset_name}, pluck="parent")
|
||||
))
|
||||
for name in parent_names:
|
||||
try:
|
||||
_cancel_and_delete("Asset Movement", name)
|
||||
deleted.append(name)
|
||||
except Exception as e:
|
||||
frappe.log_error(f"Asset Movement delete error [{name}]: {e}")
|
||||
return deleted
|
||||
|
||||
|
||||
def _del_asset_value_adjustments(asset_name: str) -> list:
|
||||
deleted = []
|
||||
for name in frappe.get_all("Asset Value Adjustment", filters={"asset": asset_name}, pluck="name"):
|
||||
try:
|
||||
_cancel_and_delete("Asset Value Adjustment", name)
|
||||
deleted.append(name)
|
||||
except Exception as e:
|
||||
frappe.log_error(f"Asset Value Adjustment delete error [{name}]: {e}")
|
||||
return deleted
|
||||
|
||||
|
||||
def _del_asset_depreciation_schedules(asset_name: str) -> list:
|
||||
deleted = []
|
||||
for name in frappe.get_all("Asset Depreciation Schedule", filters={"asset": asset_name}, pluck="name"):
|
||||
try:
|
||||
_cancel_and_delete("Asset Depreciation Schedule", name)
|
||||
deleted.append(name)
|
||||
except Exception as e:
|
||||
frappe.log_error(f"Asset Depreciation Schedule delete error [{name}]: {e}")
|
||||
return deleted
|
||||
|
||||
|
||||
def _del_asset_maintenance(asset_name: str) -> list:
|
||||
deleted = []
|
||||
for name in frappe.get_all("Asset Maintenance", filters={"asset_name": asset_name}, pluck="name"):
|
||||
try:
|
||||
_cancel_and_delete("Asset Maintenance", name)
|
||||
deleted.append(name)
|
||||
except Exception as e:
|
||||
frappe.log_error(f"Asset Maintenance delete error [{name}]: {e}")
|
||||
return deleted
|
||||
|
||||
|
||||
def _del_asset_repair(asset_name: str) -> list:
|
||||
deleted = []
|
||||
for name in frappe.get_all("Asset Repair", filters={"asset_name": asset_name}, pluck="name"):
|
||||
try:
|
||||
_cancel_and_delete("Asset Repair", name)
|
||||
deleted.append(name)
|
||||
except Exception as e:
|
||||
frappe.log_error(f"Asset Repair delete error [{name}]: {e}")
|
||||
return deleted
|
||||
|
||||
|
||||
@frappe.whitelist()
|
||||
def delete_asset(asset_name: str) -> dict:
|
||||
if not frappe.db.exists("Asset", asset_name):
|
||||
frappe.throw(_("Asset {0} does not exist.").format(asset_name), frappe.DoesNotExistError)
|
||||
|
||||
if not frappe.has_permission("Asset", "delete", asset_name):
|
||||
frappe.throw(_("You do not have permission to delete Asset {0}.").format(asset_name), frappe.PermissionError)
|
||||
|
||||
details = {}
|
||||
try:
|
||||
details["asset_activities"] = _safe_collect(_del_asset_activities, asset_name)
|
||||
details["asset_movements"] = _safe_collect(_del_asset_movements, asset_name)
|
||||
details["asset_value_adjustments"] = _safe_collect(_del_asset_value_adjustments, asset_name)
|
||||
details["asset_depreciation_schedules"] = _safe_collect(_del_asset_depreciation_schedules, asset_name)
|
||||
details["asset_maintenance"] = _safe_collect(_del_asset_maintenance, asset_name)
|
||||
# details["asset_repair"] = _safe_collect(_del_asset_repair, asset_name)
|
||||
|
||||
asset_doc = frappe.get_doc("Asset", asset_name)
|
||||
asset_doc.flags.ignore_permissions = True
|
||||
asset_doc.flags.ignore_links = True
|
||||
|
||||
if asset_doc.docstatus == 1:
|
||||
asset_doc.cancel()
|
||||
frappe.db.commit()
|
||||
|
||||
frappe.delete_doc("Asset", asset_name, force=True, ignore_permissions=True, ignore_on_trash=True)
|
||||
frappe.db.commit()
|
||||
|
||||
return {"success": True, "asset_name": asset_name, "details": details}
|
||||
|
||||
except Exception as exc:
|
||||
frappe.db.rollback()
|
||||
frappe.log_error(title=f"Asset deletion failed: {asset_name}", message=frappe.get_traceback())
|
||||
frappe.throw(_("Failed to delete asset {0}: {1}").format(asset_name, str(exc)))
|
||||
29
asset_lite/api/delete_request.py
Normal file
29
asset_lite/api/delete_request.py
Normal file
@ -0,0 +1,29 @@
|
||||
import frappe
|
||||
|
||||
@frappe.whitelist()
|
||||
def create_delete_request(target_doctype, target_name, target_display, reason, department):
|
||||
"""Create a deletion request for any doctype"""
|
||||
doc = frappe.new_doc("Delete Request")
|
||||
doc.target_doctype = target_doctype
|
||||
doc.target_name = target_name
|
||||
doc.target_display = target_display or target_name
|
||||
doc.reason = reason or ""
|
||||
doc.department = department or ""
|
||||
doc.requested_by = frappe.session.user
|
||||
doc.status = "Pending"
|
||||
doc.workflow_state = "Pending Supervisor"
|
||||
doc.insert(ignore_permissions=False)
|
||||
return {"name": doc.name, "status": "created"}
|
||||
|
||||
@frappe.whitelist()
|
||||
def get_pending_requests(doctype_filter=None):
|
||||
"""Get pending requests for current approver"""
|
||||
filters = {"workflow_state": ["in", ["Pending Supervisor", "Pending Cluster Manager"]]}
|
||||
if doctype_filter:
|
||||
filters["target_doctype"] = doctype_filter
|
||||
return frappe.get_list(
|
||||
"Delete Request",
|
||||
filters=filters,
|
||||
fields=["name", "target_doctype", "target_name", "target_display",
|
||||
"reason", "department", "requested_by", "workflow_state", "creation"]
|
||||
)
|
||||
107
asset_lite/api/doctype_fields.py
Normal file
107
asset_lite/api/doctype_fields.py
Normal file
@ -0,0 +1,107 @@
|
||||
# asset_lite/api/doctype_fields.py
|
||||
#
|
||||
# WHY THIS EXISTS:
|
||||
# Frappe's /api/resource/DocType and /api/resource/Custom Field endpoints are
|
||||
# role-filtered — they silently omit fields the current user's role cannot read.
|
||||
# This causes the export modal to show different field counts per role (6 for
|
||||
# Contractor Engineer, 45 for admin, etc.).
|
||||
#
|
||||
# This whitelisted function runs as the SYSTEM user (via frappe.get_doc /
|
||||
# frappe.get_all which bypass field-level permission checks), so it always
|
||||
# returns the complete field list regardless of who is logged in.
|
||||
# The React hook calls this endpoint instead of the meta APIs.
|
||||
|
||||
import frappe
|
||||
from frappe import _
|
||||
|
||||
# Fields that are never useful in an export UI
|
||||
SKIP_FIELDTYPES = {
|
||||
"Section Break", "Column Break", "Tab Break",
|
||||
"HTML", "Button", "Fold", "Heading",
|
||||
"Image", "Signature", "Geolocation", "Barcode",
|
||||
"Table", "Table MultiSelect",
|
||||
}
|
||||
|
||||
SKIP_FIELDNAMES = {
|
||||
"docstatus", "idx", "naming_series", "amended_from",
|
||||
"amendment_date", "lft", "rgt", "old_parent",
|
||||
}
|
||||
|
||||
# Always include these meta fields first
|
||||
META_FIELDS = [
|
||||
{"fieldname": "name", "label": "ID", "fieldtype": "Data"},
|
||||
{"fieldname": "owner", "label": "Created By", "fieldtype": "Data"},
|
||||
{"fieldname": "creation", "label": "Created On", "fieldtype": "Datetime"},
|
||||
{"fieldname": "modified_by", "label": "Modified By", "fieldtype": "Data"},
|
||||
{"fieldname": "modified", "label": "Modified On", "fieldtype": "Datetime"},
|
||||
]
|
||||
|
||||
|
||||
@frappe.whitelist()
|
||||
def get_export_fields(doctype: str) -> list:
|
||||
"""
|
||||
Returns the complete list of exportable fields for a DocType.
|
||||
Ignores field-level role permissions intentionally — this endpoint
|
||||
is for the export column picker UI only, not for data access control.
|
||||
Data access is still enforced when the actual export fetch runs.
|
||||
|
||||
Returns a list of dicts: { fieldname, label, fieldtype }
|
||||
"""
|
||||
# Basic validation — ensure the doctype itself exists and user can read it
|
||||
if not frappe.db.exists("DocType", doctype):
|
||||
frappe.throw(_("DocType {0} does not exist").format(doctype), frappe.DoesNotExistError)
|
||||
|
||||
# Check the user can at least read this doctype (doc-level permission, not field-level)
|
||||
if not frappe.has_permission(doctype, "read"):
|
||||
frappe.throw(_("No read permission for {0}").format(doctype), frappe.PermissionError)
|
||||
|
||||
meta_fieldnames = {f["fieldname"] for f in META_FIELDS}
|
||||
seen = set(meta_fieldnames)
|
||||
result = []
|
||||
|
||||
# ── Standard DocType fields ──────────────────────────────────────────────
|
||||
# frappe.get_meta() loads DocType metadata as SYSTEM — not role-filtered
|
||||
meta = frappe.get_meta(doctype)
|
||||
|
||||
for f in meta.fields:
|
||||
if f.fieldtype in SKIP_FIELDTYPES:
|
||||
continue
|
||||
if f.fieldname in SKIP_FIELDNAMES:
|
||||
continue
|
||||
if f.hidden:
|
||||
continue
|
||||
if f.fieldname in seen:
|
||||
continue
|
||||
seen.add(f.fieldname)
|
||||
result.append({
|
||||
"fieldname": f.fieldname,
|
||||
"label": f.label or f.fieldname,
|
||||
"fieldtype": f.fieldtype or "Data",
|
||||
})
|
||||
|
||||
# ── Custom fields ────────────────────────────────────────────────────────
|
||||
# frappe.get_all() with ignore_permissions=True bypasses role filtering
|
||||
custom_fields = frappe.get_all(
|
||||
"Custom Field",
|
||||
filters={"dt": doctype, "hidden": 0},
|
||||
fields=["fieldname", "label", "fieldtype"],
|
||||
ignore_permissions=True, # <-- KEY: bypasses role-based field restrictions
|
||||
limit_page_length=500,
|
||||
)
|
||||
|
||||
for f in custom_fields:
|
||||
if f.fieldtype in SKIP_FIELDTYPES:
|
||||
continue
|
||||
if f.fieldname in SKIP_FIELDNAMES:
|
||||
continue
|
||||
if f.fieldname in seen:
|
||||
continue
|
||||
seen.add(f.fieldname)
|
||||
result.append({
|
||||
"fieldname": f["fieldname"],
|
||||
"label": f["label"] or f["fieldname"],
|
||||
"fieldtype": f["fieldtype"] or "Data",
|
||||
})
|
||||
|
||||
# Return meta fields first, then the rest
|
||||
return META_FIELDS + result
|
||||
46
asset_lite/api/item_api.py
Normal file
46
asset_lite/api/item_api.py
Normal file
@ -0,0 +1,46 @@
|
||||
import frappe
|
||||
import json
|
||||
|
||||
@frappe.whitelist()
|
||||
def get_items(filters=None, fields=None, limit=20, offset=0, order_by="creation desc"):
|
||||
import json
|
||||
|
||||
if isinstance(filters, str):
|
||||
filters = json.loads(filters)
|
||||
if isinstance(fields, str):
|
||||
fields = json.loads(fields)
|
||||
if isinstance(limit, str):
|
||||
limit = int(limit)
|
||||
if isinstance(offset, str):
|
||||
offset = int(offset)
|
||||
|
||||
if not fields:
|
||||
fields = ["name", "item_code", "item_name", "item_group", "stock_uom",
|
||||
"custom_hospital_name", "custom_serial_no", "custom_date_in",
|
||||
"custom_code", "custom_type", "custom_volts", "custom_w",
|
||||
"custom_delete_status", "creation", "modified", "owner", "docstatus",
|
||||
"custom_technical_department", "disabled", "is_stock_item"]
|
||||
|
||||
data = frappe.get_all(
|
||||
"Item",
|
||||
filters=filters or [],
|
||||
fields=fields,
|
||||
limit_start=offset,
|
||||
limit_page_length=limit,
|
||||
order_by=order_by,
|
||||
ignore_permissions=False
|
||||
)
|
||||
|
||||
total_count = len(frappe.get_all(
|
||||
"Item",
|
||||
filters=filters or [],
|
||||
fields=["name"],
|
||||
limit_page_length=0, # 0 = no limit = all
|
||||
ignore_permissions=False
|
||||
))
|
||||
|
||||
return {
|
||||
"data": data,
|
||||
"total": total_count,
|
||||
"has_more": (offset + limit) < total_count
|
||||
}
|
||||
565
asset_lite/api/ppm_api.py
Normal file
565
asset_lite/api/ppm_api.py
Normal file
@ -0,0 +1,565 @@
|
||||
import frappe
|
||||
from frappe import _
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def get_asset_maintenances(filters=None, fields=None, limit=20, offset=0, order_by=None):
|
||||
"""
|
||||
Get list of asset maintenances (PPM schedules) with filters and pagination
|
||||
|
||||
Args:
|
||||
filters: JSON string of filters (e.g., '{"company": "Al Jouf Hospital"}')
|
||||
fields: JSON string of fields to return (e.g., '["asset_name", "maintenance_team"]')
|
||||
limit: Number of records to return (default: 20)
|
||||
offset: Number of records to skip (default: 0)
|
||||
order_by: Sort order (e.g., "creation desc")
|
||||
|
||||
Returns:
|
||||
{
|
||||
"asset_maintenances": [...],
|
||||
"total_count": int,
|
||||
"limit": int,
|
||||
"offset": int,
|
||||
"has_more": bool
|
||||
}
|
||||
"""
|
||||
try:
|
||||
# Parse filters if provided
|
||||
if filters and isinstance(filters, str):
|
||||
import json
|
||||
filters = json.loads(filters)
|
||||
|
||||
# Parse fields if provided
|
||||
if fields and isinstance(fields, str):
|
||||
import json
|
||||
fields = json.loads(fields)
|
||||
else:
|
||||
# Default fields to return
|
||||
fields = [
|
||||
'name',
|
||||
'company',
|
||||
'asset_name',
|
||||
'custom_asset_type',
|
||||
'asset_category',
|
||||
'custom_type_of_maintenance',
|
||||
'custom_asset_name',
|
||||
'item_code',
|
||||
'item_name',
|
||||
'maintenance_team',
|
||||
'custom_pm_schedule',
|
||||
'maintenance_manager',
|
||||
'maintenance_manager_name',
|
||||
'custom_warranty',
|
||||
'custom_warranty_status',
|
||||
'custom_service_contract',
|
||||
'custom_service_contract_status',
|
||||
'custom_frequency',
|
||||
'custom_total_amount',
|
||||
'custom_no_of_pms',
|
||||
'custom_price_per_pm',
|
||||
'creation',
|
||||
'modified',
|
||||
'owner',
|
||||
'modified_by',
|
||||
'docstatus',
|
||||
'idx'
|
||||
]
|
||||
|
||||
# Get total count
|
||||
total_count = frappe.db.count('Asset Maintenance', filters=filters or {})
|
||||
|
||||
# Get asset maintenances
|
||||
asset_maintenances = frappe.get_all(
|
||||
'Asset Maintenance',
|
||||
filters=filters or {},
|
||||
fields=fields,
|
||||
limit_page_length=int(limit),
|
||||
limit_start=int(offset),
|
||||
order_by=order_by or 'creation desc'
|
||||
)
|
||||
|
||||
# Calculate has_more
|
||||
has_more = (int(offset) + int(limit)) < total_count
|
||||
|
||||
frappe.response['message'] = {
|
||||
'asset_maintenances': asset_maintenances,
|
||||
'total_count': total_count,
|
||||
'limit': int(limit),
|
||||
'offset': int(offset),
|
||||
'has_more': has_more
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
frappe.log_error(frappe.get_traceback(), 'Get Asset Maintenances API Error')
|
||||
frappe.response['message'] = {
|
||||
'error': str(e),
|
||||
'asset_maintenances': [],
|
||||
'total_count': 0
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def get_asset_maintenance_details(maintenance_name):
|
||||
"""
|
||||
Get detailed information about a specific asset maintenance (PPM schedule)
|
||||
|
||||
Args:
|
||||
maintenance_name: Name/ID of the asset maintenance
|
||||
|
||||
Returns:
|
||||
Asset Maintenance document with all fields including child tables
|
||||
"""
|
||||
try:
|
||||
if not maintenance_name:
|
||||
frappe.throw(_('Asset Maintenance name is required'))
|
||||
|
||||
# Check if user has permission to read this maintenance
|
||||
if not frappe.has_permission('Asset Maintenance', 'read', maintenance_name):
|
||||
frappe.throw(_('Not permitted to access this asset maintenance'))
|
||||
|
||||
# Get asset maintenance details
|
||||
maintenance = frappe.get_doc('Asset Maintenance', maintenance_name)
|
||||
|
||||
frappe.response['message'] = maintenance.as_dict()
|
||||
|
||||
except Exception as e:
|
||||
frappe.log_error(frappe.get_traceback(), 'Get Asset Maintenance Details API Error')
|
||||
frappe.response['message'] = {
|
||||
'error': str(e)
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def create_asset_maintenance(maintenance_data):
|
||||
"""
|
||||
Create a new asset maintenance (PPM schedule)
|
||||
|
||||
Args:
|
||||
maintenance_data: JSON string containing asset maintenance fields
|
||||
|
||||
Returns:
|
||||
Created asset maintenance document
|
||||
"""
|
||||
try:
|
||||
import json
|
||||
|
||||
# Parse maintenance data
|
||||
if isinstance(maintenance_data, str):
|
||||
maintenance_data = json.loads(maintenance_data)
|
||||
|
||||
# Check if user has permission to create asset maintenance
|
||||
if not frappe.has_permission('Asset Maintenance', 'create'):
|
||||
frappe.throw(_('Not permitted to create asset maintenance'))
|
||||
|
||||
# Create new asset maintenance
|
||||
maintenance = frappe.get_doc({
|
||||
'doctype': 'Asset Maintenance',
|
||||
**maintenance_data
|
||||
})
|
||||
|
||||
maintenance.insert()
|
||||
frappe.db.commit()
|
||||
|
||||
frappe.response['message'] = {
|
||||
'success': True,
|
||||
'asset_maintenance': maintenance.as_dict(),
|
||||
'message': _('Asset Maintenance created successfully')
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
frappe.db.rollback()
|
||||
frappe.log_error(frappe.get_traceback(), 'Create Asset Maintenance API Error')
|
||||
frappe.response['message'] = {
|
||||
'success': False,
|
||||
'error': str(e)
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def update_asset_maintenance(maintenance_name, maintenance_data):
|
||||
"""
|
||||
Update an existing asset maintenance (PPM schedule)
|
||||
|
||||
Args:
|
||||
maintenance_name: Name/ID of the asset maintenance
|
||||
maintenance_data: JSON string containing fields to update
|
||||
|
||||
Returns:
|
||||
Updated asset maintenance document
|
||||
"""
|
||||
try:
|
||||
import json
|
||||
|
||||
if not maintenance_name:
|
||||
frappe.throw(_('Asset Maintenance name is required'))
|
||||
|
||||
# Parse maintenance data
|
||||
if isinstance(maintenance_data, str):
|
||||
maintenance_data = json.loads(maintenance_data)
|
||||
|
||||
# Check if user has permission to update this maintenance
|
||||
if not frappe.has_permission('Asset Maintenance', 'write', maintenance_name):
|
||||
frappe.throw(_('Not permitted to update this asset maintenance'))
|
||||
|
||||
# Get and update asset maintenance
|
||||
maintenance = frappe.get_doc('Asset Maintenance', maintenance_name)
|
||||
|
||||
# Update fields
|
||||
for key, value in maintenance_data.items():
|
||||
if hasattr(maintenance, key):
|
||||
setattr(maintenance, key, value)
|
||||
|
||||
maintenance.save()
|
||||
frappe.db.commit()
|
||||
|
||||
frappe.response['message'] = {
|
||||
'success': True,
|
||||
'asset_maintenance': maintenance.as_dict(),
|
||||
'message': _('Asset Maintenance updated successfully')
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
frappe.db.rollback()
|
||||
frappe.log_error(frappe.get_traceback(), 'Update Asset Maintenance API Error')
|
||||
frappe.response['message'] = {
|
||||
'success': False,
|
||||
'error': str(e)
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def delete_asset_maintenance(maintenance_name):
|
||||
"""
|
||||
Delete an asset maintenance (PPM schedule)
|
||||
|
||||
Args:
|
||||
maintenance_name: Name/ID of the asset maintenance
|
||||
|
||||
Returns:
|
||||
Success message
|
||||
"""
|
||||
try:
|
||||
if not maintenance_name:
|
||||
frappe.throw(_('Asset Maintenance name is required'))
|
||||
|
||||
# Check if user has permission to delete this maintenance
|
||||
if not frappe.has_permission('Asset Maintenance', 'delete', maintenance_name):
|
||||
frappe.throw(_('Not permitted to delete this asset maintenance'))
|
||||
|
||||
# Delete asset maintenance
|
||||
frappe.delete_doc('Asset Maintenance', maintenance_name)
|
||||
frappe.db.commit()
|
||||
|
||||
frappe.response['message'] = {
|
||||
'success': True,
|
||||
'message': _('Asset Maintenance deleted successfully')
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
frappe.db.rollback()
|
||||
frappe.log_error(frappe.get_traceback(), 'Delete Asset Maintenance API Error')
|
||||
frappe.response['message'] = {
|
||||
'success': False,
|
||||
'error': str(e)
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def get_maintenance_tasks(maintenance_name):
|
||||
"""
|
||||
Get all maintenance tasks for a specific asset maintenance
|
||||
|
||||
Args:
|
||||
maintenance_name: Name/ID of the asset maintenance
|
||||
|
||||
Returns:
|
||||
List of maintenance tasks (asset_maintenance_tasks child table)
|
||||
"""
|
||||
try:
|
||||
if not maintenance_name:
|
||||
frappe.throw(_('Asset Maintenance name is required'))
|
||||
|
||||
# Check if user has permission to read this maintenance
|
||||
if not frappe.has_permission('Asset Maintenance', 'read', maintenance_name):
|
||||
frappe.throw(_('Not permitted to access this asset maintenance'))
|
||||
|
||||
# Get maintenance tasks
|
||||
tasks = frappe.get_all(
|
||||
'Asset Maintenance Task',
|
||||
filters={'parent': maintenance_name},
|
||||
fields=['*'],
|
||||
order_by='idx asc'
|
||||
)
|
||||
|
||||
frappe.response['message'] = {
|
||||
'maintenance_tasks': tasks,
|
||||
'total_count': len(tasks)
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
frappe.log_error(frappe.get_traceback(), 'Get Maintenance Tasks API Error')
|
||||
frappe.response['message'] = {
|
||||
'error': str(e),
|
||||
'maintenance_tasks': []
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def get_service_coverage(maintenance_name):
|
||||
"""
|
||||
Get service coverage details for a specific asset maintenance
|
||||
|
||||
Args:
|
||||
maintenance_name: Name/ID of the asset maintenance
|
||||
|
||||
Returns:
|
||||
List of service coverage (custom_service_coverage_table child table)
|
||||
"""
|
||||
try:
|
||||
if not maintenance_name:
|
||||
frappe.throw(_('Asset Maintenance name is required'))
|
||||
|
||||
# Check if user has permission to read this maintenance
|
||||
if not frappe.has_permission('Asset Maintenance', 'read', maintenance_name):
|
||||
frappe.throw(_('Not permitted to access this asset maintenance'))
|
||||
|
||||
# Get service coverage
|
||||
coverage = frappe.get_all(
|
||||
'Service Coverage',
|
||||
filters={'parent': maintenance_name},
|
||||
fields=['*'],
|
||||
order_by='idx asc'
|
||||
)
|
||||
|
||||
frappe.response['message'] = {
|
||||
'service_coverage': coverage,
|
||||
'total_count': len(coverage)
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
frappe.log_error(frappe.get_traceback(), 'Get Service Coverage API Error')
|
||||
frappe.response['message'] = {
|
||||
'error': str(e),
|
||||
'service_coverage': []
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def add_maintenance_task(maintenance_name, task_data):
|
||||
"""
|
||||
Add a new maintenance task to an asset maintenance
|
||||
|
||||
Args:
|
||||
maintenance_name: Name/ID of the asset maintenance
|
||||
task_data: JSON string containing task fields
|
||||
|
||||
Returns:
|
||||
Updated asset maintenance document
|
||||
"""
|
||||
try:
|
||||
import json
|
||||
|
||||
if not maintenance_name:
|
||||
frappe.throw(_('Asset Maintenance name is required'))
|
||||
|
||||
# Parse task data
|
||||
if isinstance(task_data, str):
|
||||
task_data = json.loads(task_data)
|
||||
|
||||
# Check if user has permission to update this maintenance
|
||||
if not frappe.has_permission('Asset Maintenance', 'write', maintenance_name):
|
||||
frappe.throw(_('Not permitted to update this asset maintenance'))
|
||||
|
||||
# Get asset maintenance
|
||||
maintenance = frappe.get_doc('Asset Maintenance', maintenance_name)
|
||||
|
||||
# Add new task
|
||||
maintenance.append('asset_maintenance_tasks', task_data)
|
||||
maintenance.save()
|
||||
frappe.db.commit()
|
||||
|
||||
frappe.response['message'] = {
|
||||
'success': True,
|
||||
'asset_maintenance': maintenance.as_dict(),
|
||||
'message': _('Maintenance task added successfully')
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
frappe.db.rollback()
|
||||
frappe.log_error(frappe.get_traceback(), 'Add Maintenance Task API Error')
|
||||
frappe.response['message'] = {
|
||||
'success': False,
|
||||
'error': str(e)
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def update_maintenance_task(task_name, task_data):
|
||||
"""
|
||||
Update a specific maintenance task
|
||||
|
||||
Args:
|
||||
task_name: Name/ID of the maintenance task
|
||||
task_data: JSON string containing fields to update
|
||||
|
||||
Returns:
|
||||
Updated task details
|
||||
"""
|
||||
try:
|
||||
import json
|
||||
|
||||
if not task_name:
|
||||
frappe.throw(_('Maintenance task name is required'))
|
||||
|
||||
# Parse task data
|
||||
if isinstance(task_data, str):
|
||||
task_data = json.loads(task_data)
|
||||
|
||||
# Get the task to find parent
|
||||
task = frappe.get_doc('Asset Maintenance Task', task_name)
|
||||
|
||||
# Check if user has permission to update parent maintenance
|
||||
if not frappe.has_permission('Asset Maintenance', 'write', task.parent):
|
||||
frappe.throw(_('Not permitted to update this maintenance task'))
|
||||
|
||||
# Update task fields
|
||||
for key, value in task_data.items():
|
||||
if hasattr(task, key):
|
||||
setattr(task, key, value)
|
||||
|
||||
task.save()
|
||||
frappe.db.commit()
|
||||
|
||||
frappe.response['message'] = {
|
||||
'success': True,
|
||||
'maintenance_task': task.as_dict(),
|
||||
'message': _('Maintenance task updated successfully')
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
frappe.db.rollback()
|
||||
frappe.log_error(frappe.get_traceback(), 'Update Maintenance Task API Error')
|
||||
frappe.response['message'] = {
|
||||
'success': False,
|
||||
'error': str(e)
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def get_maintenances_by_asset(asset_name, filters=None, limit=20, offset=0):
|
||||
"""
|
||||
Get all maintenance schedules for a specific asset
|
||||
|
||||
Args:
|
||||
asset_name: Name/ID of the asset
|
||||
filters: Additional JSON string of filters
|
||||
limit: Number of records to return (default: 20)
|
||||
offset: Number of records to skip (default: 0)
|
||||
|
||||
Returns:
|
||||
List of maintenance schedules for the asset
|
||||
"""
|
||||
try:
|
||||
import json
|
||||
|
||||
if not asset_name:
|
||||
frappe.throw(_('Asset name is required'))
|
||||
|
||||
# Parse additional filters if provided
|
||||
additional_filters = {}
|
||||
if filters and isinstance(filters, str):
|
||||
additional_filters = json.loads(filters)
|
||||
|
||||
# Combine filters
|
||||
combined_filters = {'asset_name': asset_name, **additional_filters}
|
||||
|
||||
# Get total count
|
||||
total_count = frappe.db.count('Asset Maintenance', filters=combined_filters)
|
||||
|
||||
# Get maintenances
|
||||
maintenances = frappe.get_all(
|
||||
'Asset Maintenance',
|
||||
filters=combined_filters,
|
||||
fields=['*'],
|
||||
limit_page_length=int(limit),
|
||||
limit_start=int(offset),
|
||||
order_by='creation desc'
|
||||
)
|
||||
|
||||
# Calculate has_more
|
||||
has_more = (int(offset) + int(limit)) < total_count
|
||||
|
||||
frappe.response['message'] = {
|
||||
'asset_maintenances': maintenances,
|
||||
'total_count': total_count,
|
||||
'limit': int(limit),
|
||||
'offset': int(offset),
|
||||
'has_more': has_more
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
frappe.log_error(frappe.get_traceback(), 'Get Maintenances By Asset API Error')
|
||||
frappe.response['message'] = {
|
||||
'error': str(e),
|
||||
'asset_maintenances': [],
|
||||
'total_count': 0
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def get_active_service_contracts(filters=None, limit=20, offset=0):
|
||||
"""
|
||||
Get all asset maintenances with active service contracts
|
||||
|
||||
Args:
|
||||
filters: Additional JSON string of filters
|
||||
limit: Number of records to return (default: 20)
|
||||
offset: Number of records to skip (default: 0)
|
||||
|
||||
Returns:
|
||||
List of asset maintenances with active contracts
|
||||
"""
|
||||
try:
|
||||
import json
|
||||
|
||||
# Parse additional filters if provided
|
||||
additional_filters = {}
|
||||
if filters and isinstance(filters, str):
|
||||
additional_filters = json.loads(filters)
|
||||
|
||||
# Combine filters - get maintenances with service contract = 1
|
||||
combined_filters = {
|
||||
'custom_service_contract': 1,
|
||||
**additional_filters
|
||||
}
|
||||
|
||||
# Get total count
|
||||
total_count = frappe.db.count('Asset Maintenance', filters=combined_filters)
|
||||
|
||||
# Get maintenances
|
||||
maintenances = frappe.get_all(
|
||||
'Asset Maintenance',
|
||||
filters=combined_filters,
|
||||
fields=['*'],
|
||||
limit_page_length=int(limit),
|
||||
limit_start=int(offset),
|
||||
order_by='creation desc'
|
||||
)
|
||||
|
||||
# Calculate has_more
|
||||
has_more = (int(offset) + int(limit)) < total_count
|
||||
|
||||
frappe.response['message'] = {
|
||||
'asset_maintenances': maintenances,
|
||||
'total_count': total_count,
|
||||
'limit': int(limit),
|
||||
'offset': int(offset),
|
||||
'has_more': has_more
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
frappe.log_error(frappe.get_traceback(), 'Get Active Service Contracts API Error')
|
||||
frappe.response['message'] = {
|
||||
'error': str(e),
|
||||
'asset_maintenances': [],
|
||||
'total_count': 0
|
||||
}
|
||||
1197
asset_lite/api/ppm_generator_api.py
Normal file
1197
asset_lite/api/ppm_generator_api.py
Normal file
File diff suppressed because it is too large
Load Diff
214
asset_lite/api/room_filter.py
Normal file
214
asset_lite/api/room_filter.py
Normal file
@ -0,0 +1,214 @@
|
||||
import frappe
|
||||
import json
|
||||
|
||||
@frappe.whitelist()
|
||||
def get_filtered_rooms(txt='', doctype='Room', searchfield='name', start=0, page_len=50, filters=None):
|
||||
"""
|
||||
Custom query for Room LinkField that filters based on Infrastructure Location mapping.
|
||||
Returns rooms that are mapped to the specified building/department in Infrastructure Location.
|
||||
"""
|
||||
# Parse filters if string
|
||||
if isinstance(filters, str):
|
||||
try:
|
||||
filters = json.loads(filters)
|
||||
except:
|
||||
filters = {}
|
||||
|
||||
if not filters:
|
||||
filters = {}
|
||||
|
||||
building = filters.get('building', '')
|
||||
department = filters.get('department', '')
|
||||
|
||||
txt = txt or ''
|
||||
start = int(start)
|
||||
page_len = int(page_len)
|
||||
|
||||
# If building or department is specified, filter via Infrastructure Location
|
||||
if building or department:
|
||||
infra_conditions = []
|
||||
values = {
|
||||
'txt': f'%{txt}%',
|
||||
'start': start,
|
||||
'page_len': page_len
|
||||
}
|
||||
|
||||
if building:
|
||||
infra_conditions.append("il.building = %(building)s")
|
||||
values['building'] = building
|
||||
|
||||
if department:
|
||||
infra_conditions.append("il.department = %(department)s")
|
||||
values['department'] = department
|
||||
|
||||
infra_where = " AND ".join(infra_conditions)
|
||||
|
||||
# Query rooms that exist in Infrastructure Location with given filters
|
||||
query = f"""
|
||||
SELECT DISTINCT r.name, r.name as description
|
||||
FROM `tabRoom` r
|
||||
INNER JOIN `tabInfrastructure Location` il ON il.room_no = r.name
|
||||
WHERE ({infra_where})
|
||||
AND r.name LIKE %(txt)s
|
||||
ORDER BY r.name
|
||||
LIMIT %(start)s, %(page_len)s
|
||||
"""
|
||||
|
||||
results = frappe.db.sql(query, values, as_list=True)
|
||||
else:
|
||||
# No building/department filter - return all rooms matching search text
|
||||
results = frappe.db.sql("""
|
||||
SELECT name, name as description
|
||||
FROM `tabRoom`
|
||||
WHERE name LIKE %(txt)s
|
||||
ORDER BY name
|
||||
LIMIT %(start)s, %(page_len)s
|
||||
""", {
|
||||
'txt': f'%{txt}%',
|
||||
'start': start,
|
||||
'page_len': page_len
|
||||
}, as_list=True)
|
||||
|
||||
return results
|
||||
|
||||
|
||||
@frappe.whitelist()
|
||||
def get_filtered_departments(txt='', doctype='Department', searchfield='name', start=0, page_len=50, filters=None):
|
||||
"""
|
||||
Custom query for Department LinkField that filters based on Infrastructure Location mapping.
|
||||
Returns departments that are mapped to the specified building in Infrastructure Location.
|
||||
"""
|
||||
# Parse filters if string
|
||||
if isinstance(filters, str):
|
||||
try:
|
||||
filters = json.loads(filters)
|
||||
except:
|
||||
filters = {}
|
||||
|
||||
if not filters:
|
||||
filters = {}
|
||||
|
||||
building = filters.get('building', '')
|
||||
company = filters.get('company', '')
|
||||
|
||||
txt = txt or ''
|
||||
start = int(start)
|
||||
page_len = int(page_len)
|
||||
|
||||
values = {
|
||||
'txt': f'%{txt}%',
|
||||
'start': start,
|
||||
'page_len': page_len
|
||||
}
|
||||
|
||||
# If building is specified, filter via Infrastructure Location
|
||||
if building:
|
||||
query = """
|
||||
SELECT DISTINCT d.name, d.name as description
|
||||
FROM `tabDepartment` d
|
||||
INNER JOIN `tabInfrastructure Location` il ON il.department = d.name
|
||||
WHERE il.building = %(building)s
|
||||
AND d.name LIKE %(txt)s
|
||||
"""
|
||||
values['building'] = building
|
||||
|
||||
# Add company filter if provided
|
||||
if company:
|
||||
query += " AND d.company = %(company)s"
|
||||
values['company'] = company
|
||||
|
||||
query += """
|
||||
ORDER BY d.name
|
||||
LIMIT %(start)s, %(page_len)s
|
||||
"""
|
||||
|
||||
results = frappe.db.sql(query, values, as_list=True)
|
||||
else:
|
||||
# No building filter - return departments with optional company filter
|
||||
if company:
|
||||
results = frappe.db.sql("""
|
||||
SELECT name, name as description
|
||||
FROM `tabDepartment`
|
||||
WHERE name LIKE %(txt)s
|
||||
AND company = %(company)s
|
||||
ORDER BY name
|
||||
LIMIT %(start)s, %(page_len)s
|
||||
""", {
|
||||
'txt': f'%{txt}%',
|
||||
'company': company,
|
||||
'start': start,
|
||||
'page_len': page_len
|
||||
}, as_list=True)
|
||||
else:
|
||||
results = frappe.db.sql("""
|
||||
SELECT name, name as description
|
||||
FROM `tabDepartment`
|
||||
WHERE name LIKE %(txt)s
|
||||
ORDER BY name
|
||||
LIMIT %(start)s, %(page_len)s
|
||||
""", {
|
||||
'txt': f'%{txt}%',
|
||||
'start': start,
|
||||
'page_len': page_len
|
||||
}, as_list=True)
|
||||
|
||||
return results
|
||||
|
||||
|
||||
@frappe.whitelist()
|
||||
def get_room_count(building=None, department=None):
|
||||
"""
|
||||
Get count of rooms for a building/department combination from Infrastructure Location.
|
||||
Used to show "X room(s) available" message.
|
||||
"""
|
||||
if not building and not department:
|
||||
return frappe.db.count('Room')
|
||||
|
||||
conditions = []
|
||||
values = {}
|
||||
|
||||
if building:
|
||||
conditions.append("building = %(building)s")
|
||||
values['building'] = building
|
||||
|
||||
if department:
|
||||
conditions.append("department = %(department)s")
|
||||
values['department'] = department
|
||||
|
||||
where_clause = " AND ".join(conditions)
|
||||
|
||||
count = frappe.db.sql(f"""
|
||||
SELECT COUNT(DISTINCT room_no)
|
||||
FROM `tabInfrastructure Location`
|
||||
WHERE {where_clause}
|
||||
AND room_no IS NOT NULL
|
||||
AND room_no != ''
|
||||
""", values)[0][0]
|
||||
|
||||
return count or 0
|
||||
|
||||
|
||||
@frappe.whitelist()
|
||||
def get_department_count(building=None, company=None):
|
||||
"""
|
||||
Get count of departments for a building from Infrastructure Location.
|
||||
Used to show "X department(s) available" message.
|
||||
"""
|
||||
if not building:
|
||||
if company:
|
||||
return frappe.db.count('Department', {'company': company})
|
||||
return frappe.db.count('Department')
|
||||
|
||||
values = {'building': building}
|
||||
|
||||
query = """
|
||||
SELECT COUNT(DISTINCT department)
|
||||
FROM `tabInfrastructure Location`
|
||||
WHERE building = %(building)s
|
||||
AND department IS NOT NULL
|
||||
AND department != ''
|
||||
"""
|
||||
|
||||
count = frappe.db.sql(query, values)[0][0]
|
||||
|
||||
return count or 0
|
||||
139
asset_lite/api/translation_api.py
Normal file
139
asset_lite/api/translation_api.py
Normal file
@ -0,0 +1,139 @@
|
||||
import frappe
|
||||
from frappe import _
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def get_translations(language='en'):
|
||||
"""
|
||||
Get all translations for a specific language from Frappe's Translation doctype
|
||||
This returns a dictionary of source text -> translated text
|
||||
|
||||
Usage: /api/method/asset_lite.api.translation_api.get_translations?language=ar
|
||||
|
||||
Args:
|
||||
language: Language code (e.g., 'en', 'ar')
|
||||
|
||||
Returns:
|
||||
Dictionary mapping source text to translated text
|
||||
"""
|
||||
try:
|
||||
# Validate language parameter
|
||||
if not language:
|
||||
language = 'en'
|
||||
|
||||
# Get all translations for the specified language
|
||||
translations = frappe.get_all(
|
||||
'Translation',
|
||||
filters={
|
||||
'language': language
|
||||
},
|
||||
fields=['source_text', 'translated_text'],
|
||||
limit_page_length=0 # 0 means no limit (get all)
|
||||
)
|
||||
|
||||
# Convert to dictionary format: {source_text: translated_text}
|
||||
translation_dict = {}
|
||||
for trans in translations:
|
||||
source = trans.get('source_text')
|
||||
translated = trans.get('translated_text')
|
||||
if source and translated:
|
||||
translation_dict[source] = translated
|
||||
|
||||
return {
|
||||
"success": True,
|
||||
"language": language,
|
||||
"count": len(translation_dict),
|
||||
"translations": translation_dict
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
frappe.log_error(f"Error in get_translations: {str(e)}", "Translation API Error")
|
||||
return {
|
||||
"success": False,
|
||||
"error": str(e),
|
||||
"translations": {}
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest=False)
|
||||
def get_available_languages():
|
||||
"""
|
||||
Get list of all available languages that have translations
|
||||
|
||||
Usage: /api/method/asset_lite.api.translation_api.get_available_languages
|
||||
|
||||
Returns:
|
||||
List of language codes (e.g., ['en', 'ar'])
|
||||
"""
|
||||
try:
|
||||
# Get distinct languages from Translation doctype
|
||||
languages = frappe.db.sql("""
|
||||
SELECT DISTINCT language
|
||||
FROM `tabTranslation`
|
||||
WHERE language IS NOT NULL AND language != ''
|
||||
ORDER BY language
|
||||
""", as_dict=True)
|
||||
|
||||
language_list = [lang['language'] for lang in languages if lang.get('language')]
|
||||
|
||||
# Always include English as default
|
||||
if 'en' not in language_list:
|
||||
language_list.insert(0, 'en')
|
||||
|
||||
return {
|
||||
"success": True,
|
||||
"languages": language_list
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
frappe.log_error(f"Error in get_available_languages: {str(e)}", "Translation API Error")
|
||||
return {
|
||||
"success": False,
|
||||
"error": str(e),
|
||||
"languages": ['en']
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest=False)
|
||||
def get_translation(source_text, language='ar'):
|
||||
"""
|
||||
Get a single translation for a specific text
|
||||
|
||||
Usage: /api/method/asset_lite.api.translation_api.get_translation?source_text=Comprehensive&language=ar
|
||||
|
||||
Args:
|
||||
source_text: The text to translate
|
||||
language: Target language code (default: 'ar')
|
||||
|
||||
Returns:
|
||||
Translated text or original if not found
|
||||
"""
|
||||
try:
|
||||
if not source_text:
|
||||
return {
|
||||
"success": False,
|
||||
"error": "source_text is required"
|
||||
}
|
||||
|
||||
translation = frappe.db.get_value(
|
||||
'Translation',
|
||||
filters={
|
||||
'language': language,
|
||||
'source_text': source_text
|
||||
},
|
||||
fieldname='translated_text'
|
||||
)
|
||||
|
||||
return {
|
||||
"success": True,
|
||||
"source_text": source_text,
|
||||
"translated_text": translation or source_text, # Return original if not found
|
||||
"found": bool(translation)
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
frappe.log_error(f"Error in get_translation: {str(e)}", "Translation API Error")
|
||||
return {
|
||||
"success": False,
|
||||
"error": str(e),
|
||||
"translated_text": source_text
|
||||
}
|
||||
152
asset_lite/api/user_roles.py
Normal file
152
asset_lite/api/user_roles.py
Normal file
@ -0,0 +1,152 @@
|
||||
import frappe
|
||||
|
||||
@frappe.whitelist()
|
||||
def get_user_roles():
|
||||
"""Get roles for the current logged-in user - no permission check needed"""
|
||||
user = frappe.session.user
|
||||
|
||||
if not user or user == "Guest":
|
||||
return []
|
||||
|
||||
# Get roles using ignore_permissions
|
||||
roles = frappe.get_roles(user)
|
||||
|
||||
return roles
|
||||
|
||||
|
||||
@frappe.whitelist()
|
||||
def get_user_info_with_roles():
|
||||
"""Get current user info along with their roles"""
|
||||
user = frappe.session.user
|
||||
|
||||
if not user or user == "Guest":
|
||||
return {"user": None, "roles": []}
|
||||
|
||||
roles = frappe.get_roles(user)
|
||||
|
||||
return {
|
||||
"user": user,
|
||||
"roles": roles,
|
||||
"full_name": frappe.db.get_value("User", user, "full_name")
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest=False)
|
||||
def check_has_role(roles):
|
||||
"""Check if current user has any of the specified roles
|
||||
|
||||
Args:
|
||||
roles: comma-separated string or list of role names
|
||||
|
||||
Returns:
|
||||
dict with has_role (bool) and matching_roles (list)
|
||||
"""
|
||||
user = frappe.session.user
|
||||
|
||||
if not user or user == "Guest":
|
||||
return {"has_role": False, "matching_roles": [], "user_roles": []}
|
||||
|
||||
# Handle both string and list input
|
||||
if isinstance(roles, str):
|
||||
check_roles = [r.strip() for r in roles.split(",")]
|
||||
else:
|
||||
check_roles = roles
|
||||
|
||||
user_roles = frappe.get_roles(user)
|
||||
matching_roles = [r for r in check_roles if r in user_roles]
|
||||
|
||||
return {
|
||||
"has_role": len(matching_roles) > 0,
|
||||
"matching_roles": matching_roles,
|
||||
"user_roles": user_roles
|
||||
}
|
||||
|
||||
@frappe.whitelist()
|
||||
def get_users_with_role(role):
|
||||
"""
|
||||
Get all enabled users who have a specific role
|
||||
|
||||
Args:
|
||||
role: Role name (e.g., 'Technician')
|
||||
|
||||
Returns:
|
||||
List of users with name and full_name
|
||||
"""
|
||||
if not role:
|
||||
return []
|
||||
|
||||
# Get all users who have this role from Has Role child table
|
||||
users_with_role = frappe.get_all(
|
||||
"Has Role",
|
||||
filters={
|
||||
"role": role,
|
||||
"parenttype": "User"
|
||||
},
|
||||
fields=["parent"],
|
||||
distinct=True
|
||||
)
|
||||
|
||||
if not users_with_role:
|
||||
return []
|
||||
|
||||
user_names = [u.parent for u in users_with_role]
|
||||
|
||||
# Get user details for enabled users only
|
||||
user_details = frappe.get_all(
|
||||
"User",
|
||||
filters={
|
||||
"name": ["in", user_names],
|
||||
"enabled": 1
|
||||
},
|
||||
fields=["name", "full_name"],
|
||||
order_by="full_name asc"
|
||||
)
|
||||
|
||||
return user_details
|
||||
|
||||
@frappe.whitelist()
|
||||
def has_create_permission(doctype):
|
||||
"""
|
||||
Check if current user has create permission for a doctype
|
||||
Uses ignore_permissions to query Custom DocPerm
|
||||
"""
|
||||
user = frappe.session.user
|
||||
|
||||
if not user or user == "Guest":
|
||||
return {"has_permission": False, "reason": "Not logged in"}
|
||||
|
||||
# Get user's roles
|
||||
user_roles = frappe.get_roles(user)
|
||||
|
||||
# System Manager and Administrator always have permission
|
||||
if "System Manager" in user_roles or "Administrator" in user_roles:
|
||||
return {
|
||||
"has_permission": True,
|
||||
"reason": "System Manager/Administrator",
|
||||
"role": "System Manager"
|
||||
}
|
||||
|
||||
# Check Custom DocPerm with ignore_permissions=True
|
||||
custom_perms = frappe.get_all(
|
||||
"Custom DocPerm",
|
||||
filters={
|
||||
"parent": doctype,
|
||||
"role": ["in", user_roles],
|
||||
"create": 1
|
||||
},
|
||||
fields=["name", "role"],
|
||||
ignore_permissions=True, # ← This is the key!
|
||||
limit=1
|
||||
)
|
||||
|
||||
if custom_perms and len(custom_perms) > 0:
|
||||
return {
|
||||
"has_permission": True,
|
||||
"reason": "Custom DocPerm",
|
||||
"role": custom_perms[0].get("role")
|
||||
}
|
||||
|
||||
return {
|
||||
"has_permission": False,
|
||||
"reason": "No create permission found in Custom DocPerm"
|
||||
}
|
||||
310
asset_lite/api/userperm_api.py
Normal file
310
asset_lite/api/userperm_api.py
Normal file
@ -0,0 +1,310 @@
|
||||
import frappe
|
||||
from frappe import _
|
||||
|
||||
# ============================================================================
|
||||
# CONFIGURATION: Define field mappings for each doctype
|
||||
# Add new doctypes here as needed - this is the ONLY place you need to update
|
||||
# ============================================================================
|
||||
|
||||
DOCTYPE_PERMISSION_MAPPINGS = {
|
||||
"Asset": {
|
||||
"Company": "company",
|
||||
"Location": "location",
|
||||
"Department": "department",
|
||||
"Manufacturer": "custom_manufacturer",
|
||||
"Supplier": "supplier",
|
||||
"Modality": "custom_modality",
|
||||
"Cost Center": "cost_center",
|
||||
"Asset Type":"custom_asset_type",
|
||||
"Asset Category": "asset_category"
|
||||
},
|
||||
"Work_Order": {
|
||||
"Company": "company",
|
||||
"Location": "location",
|
||||
"Department": "department",
|
||||
"Issue Type": "work_order_type"
|
||||
|
||||
},
|
||||
"Asset Maintenance": {
|
||||
"Company": "company",
|
||||
"Asset": "asset_name",
|
||||
"Supplier": "supplier"
|
||||
},
|
||||
"Asset Maintenance Log": {
|
||||
"Company": "company",
|
||||
"Asset": "asset_name"
|
||||
}
|
||||
# Add more doctypes as needed - just add them here!
|
||||
}
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# HELPER FUNCTION
|
||||
# ============================================================================
|
||||
|
||||
def is_system_user(user):
|
||||
"""Check if user is Administrator or has System Manager role."""
|
||||
if user == "Administrator":
|
||||
return True
|
||||
|
||||
roles = frappe.get_roles(user)
|
||||
return "System Manager" in roles
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# CORE API FUNCTIONS - These 4 functions handle everything
|
||||
# ============================================================================
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def get_user_permissions(user=None):
|
||||
"""
|
||||
Get all user permissions for the logged-in user.
|
||||
|
||||
Returns:
|
||||
dict: User permissions grouped by 'allow' doctype
|
||||
"""
|
||||
if not user:
|
||||
user = frappe.session.user
|
||||
|
||||
if is_system_user(user):
|
||||
return {
|
||||
"is_admin": True,
|
||||
"permissions": {},
|
||||
"user": user,
|
||||
"total_permissions": 0
|
||||
}
|
||||
|
||||
permissions = frappe.get_all(
|
||||
"User Permission",
|
||||
filters={"user": user},
|
||||
fields=["name", "allow", "for_value", "is_default", "apply_to_all_doctypes", "applicable_for"],
|
||||
order_by="allow asc"
|
||||
)
|
||||
|
||||
# Group by 'allow' doctype
|
||||
grouped = {}
|
||||
for perm in permissions:
|
||||
allow_doctype = perm.get("allow")
|
||||
if allow_doctype not in grouped:
|
||||
grouped[allow_doctype] = []
|
||||
grouped[allow_doctype].append({
|
||||
"for_value": perm.get("for_value"),
|
||||
"is_default": perm.get("is_default"),
|
||||
"apply_to_all_doctypes": perm.get("apply_to_all_doctypes"),
|
||||
"applicable_for": perm.get("applicable_for")
|
||||
})
|
||||
|
||||
return {
|
||||
"is_admin": False,
|
||||
"permissions": grouped,
|
||||
"user": user,
|
||||
"total_permissions": len(permissions),
|
||||
"permission_types": list(grouped.keys())
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def get_permission_filters(target_doctype, user=None):
|
||||
"""
|
||||
Get permission filters for ANY doctype.
|
||||
This is the MAIN function - use this for all doctypes.
|
||||
|
||||
Args:
|
||||
target_doctype: The doctype (e.g., "Asset", "Work Order", "Project")
|
||||
user: Optional user email
|
||||
|
||||
Returns:
|
||||
dict: Filters to apply for queries
|
||||
"""
|
||||
if not user:
|
||||
user = frappe.session.user
|
||||
|
||||
# System users have full access
|
||||
if is_system_user(user):
|
||||
return {
|
||||
"is_admin": True,
|
||||
"filters": {},
|
||||
"restrictions": {},
|
||||
"target_doctype": target_doctype,
|
||||
"user": user
|
||||
}
|
||||
|
||||
# Get field mapping for this doctype
|
||||
field_mapping = DOCTYPE_PERMISSION_MAPPINGS.get(target_doctype, {})
|
||||
|
||||
if not field_mapping:
|
||||
return {
|
||||
"is_admin": False,
|
||||
"filters": {},
|
||||
"restrictions": {},
|
||||
"target_doctype": target_doctype,
|
||||
"user": user,
|
||||
"warning": f"No permission mapping defined for {target_doctype}"
|
||||
}
|
||||
|
||||
filters = {}
|
||||
restrictions = {}
|
||||
|
||||
for allow_doctype, target_field in field_mapping.items():
|
||||
permissions = frappe.get_all(
|
||||
"User Permission",
|
||||
filters={
|
||||
"user": user,
|
||||
"allow": allow_doctype
|
||||
},
|
||||
fields=["for_value", "applicable_for", "apply_to_all_doctypes"]
|
||||
)
|
||||
|
||||
if permissions:
|
||||
# Filter permissions that apply to this doctype
|
||||
applicable = [
|
||||
p for p in permissions
|
||||
if p.get("apply_to_all_doctypes") == 1
|
||||
or not p.get("applicable_for")
|
||||
or p.get("applicable_for") == target_doctype
|
||||
]
|
||||
|
||||
if applicable:
|
||||
allowed_values = list(set([p.get("for_value") for p in applicable]))
|
||||
filters[target_field] = ["in", allowed_values]
|
||||
restrictions[allow_doctype] = {
|
||||
"field": target_field,
|
||||
"values": allowed_values,
|
||||
"count": len(allowed_values)
|
||||
}
|
||||
|
||||
return {
|
||||
"is_admin": False,
|
||||
"filters": filters,
|
||||
"restrictions": restrictions,
|
||||
"target_doctype": target_doctype,
|
||||
"user": user,
|
||||
"total_restrictions": len(restrictions)
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def get_allowed_values(allow_doctype, user=None):
|
||||
"""
|
||||
Get allowed values for a specific permission type.
|
||||
|
||||
Args:
|
||||
allow_doctype: e.g., "Company", "Location", "Department"
|
||||
user: Optional user email
|
||||
|
||||
Returns:
|
||||
dict: List of allowed values
|
||||
"""
|
||||
if not user:
|
||||
user = frappe.session.user
|
||||
|
||||
if is_system_user(user):
|
||||
return {
|
||||
"is_admin": True,
|
||||
"allowed_values": [],
|
||||
"has_restriction": False
|
||||
}
|
||||
|
||||
permissions = frappe.get_all(
|
||||
"User Permission",
|
||||
filters={"user": user, "allow": allow_doctype},
|
||||
fields=["for_value", "is_default"]
|
||||
)
|
||||
|
||||
allowed_values = list(set([p.get("for_value") for p in permissions]))
|
||||
default_value = next((p.get("for_value") for p in permissions if p.get("is_default")), None)
|
||||
|
||||
return {
|
||||
"is_admin": False,
|
||||
"allowed_values": sorted(allowed_values),
|
||||
"default_value": default_value,
|
||||
"has_restriction": len(allowed_values) > 0,
|
||||
"allow_doctype": allow_doctype
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def check_document_access(doctype, docname, user=None):
|
||||
"""
|
||||
Check if user has access to a specific document.
|
||||
|
||||
Args:
|
||||
doctype: e.g., "Asset", "Work Order"
|
||||
docname: The document name/ID
|
||||
user: Optional user email
|
||||
|
||||
Returns:
|
||||
dict: Access status
|
||||
"""
|
||||
if not user:
|
||||
user = frappe.session.user
|
||||
|
||||
if is_system_user(user):
|
||||
return {"has_access": True, "is_admin": True}
|
||||
|
||||
try:
|
||||
doc = frappe.get_doc(doctype, docname)
|
||||
except frappe.DoesNotExistError:
|
||||
return {"has_access": False, "error": f"{doctype} '{docname}' not found"}
|
||||
except frappe.PermissionError:
|
||||
return {"has_access": False, "error": "Permission denied"}
|
||||
|
||||
# Get permission filters
|
||||
perm_result = get_permission_filters(doctype, user)
|
||||
|
||||
if perm_result.get("is_admin"):
|
||||
return {"has_access": True, "is_admin": True}
|
||||
|
||||
restrictions = perm_result.get("restrictions", {})
|
||||
|
||||
if not restrictions:
|
||||
return {"has_access": True, "no_restrictions": True}
|
||||
|
||||
# Check each restriction
|
||||
for allow_doctype, info in restrictions.items():
|
||||
field = info.get("field")
|
||||
allowed_values = info.get("values", [])
|
||||
doc_value = getattr(doc, field, None)
|
||||
|
||||
if doc_value and doc_value not in allowed_values:
|
||||
return {
|
||||
"has_access": False,
|
||||
"denied_by": allow_doctype,
|
||||
"field": field,
|
||||
"document_value": doc_value,
|
||||
"allowed_values": allowed_values
|
||||
}
|
||||
|
||||
return {"has_access": True}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def get_configured_doctypes():
|
||||
"""Get list of doctypes that have permission mappings configured."""
|
||||
return {
|
||||
"doctypes": list(DOCTYPE_PERMISSION_MAPPINGS.keys()),
|
||||
"mappings": {
|
||||
dt: list(mapping.keys())
|
||||
for dt, mapping in DOCTYPE_PERMISSION_MAPPINGS.items()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest = True)
|
||||
def get_user_defaults(user=None):
|
||||
"""Get default values from user permissions (where is_default=1)."""
|
||||
if not user:
|
||||
user = frappe.session.user
|
||||
|
||||
if is_system_user(user):
|
||||
return {"is_admin": True, "defaults": {}}
|
||||
|
||||
permissions = frappe.get_all(
|
||||
"User Permission",
|
||||
filters={"user": user, "is_default": 1},
|
||||
fields=["allow", "for_value"]
|
||||
)
|
||||
|
||||
defaults = {p.get("allow"): p.get("for_value") for p in permissions}
|
||||
|
||||
return {"is_admin": False, "defaults": defaults}
|
||||
20
asset_lite/api/wo_feedback_api.py
Normal file
20
asset_lite/api/wo_feedback_api.py
Normal file
@ -0,0 +1,20 @@
|
||||
import frappe
|
||||
from frappe import _
|
||||
|
||||
|
||||
@frappe.whitelist(allow_guest=True)
|
||||
def get_wo_feedback_for_work_order(work_order: str | None = None):
|
||||
"""Guest-safe read for WO Feedback (autoname = work_order field value)."""
|
||||
if not work_order or not str(work_order).strip():
|
||||
frappe.throw(_("Work Order is required"))
|
||||
|
||||
work_order = str(work_order).strip()
|
||||
if not frappe.db.exists("WO Feedback", work_order):
|
||||
return None
|
||||
|
||||
return frappe.db.get_value(
|
||||
"WO Feedback",
|
||||
work_order,
|
||||
["name", "work_order", "requester_name", "rating", "comments"],
|
||||
as_dict=True,
|
||||
)
|
||||
1067
asset_lite/api/work_order_api.py
Normal file
1067
asset_lite/api/work_order_api.py
Normal file
File diff suppressed because it is too large
Load Diff
0
asset_lite/asset_lite/__init__.py
Normal file
0
asset_lite/asset_lite/__init__.py
Normal file
@ -0,0 +1,47 @@
|
||||
frappe.dashboards.chart_sources["Active Map Widget"] = {
|
||||
method: "asset_lite.map.get_custom_html_data",
|
||||
filters: []
|
||||
};
|
||||
|
||||
// Override the chart rendering after data is loaded
|
||||
frappe.provide('frappe.dashboards');
|
||||
|
||||
$(document).on('app_ready', function() {
|
||||
// Override the render method for custom HTML charts
|
||||
const original_render = frappe.ui.Dashboard.prototype.render_chart;
|
||||
|
||||
frappe.ui.Dashboard.prototype.render_chart = function(chart_data, chart_container) {
|
||||
if (chart_data.custom_html) {
|
||||
// Clear the container and add custom HTML
|
||||
chart_container.empty();
|
||||
const custom_html = `
|
||||
<div style="padding: 20px; background: #f8f9fa; border-radius: 8px; margin: 10px;">
|
||||
<h4 style="margin-bottom: 15px; color: #333;">Custom Dashboard Content</h4>
|
||||
<div class="row">
|
||||
<div class="col-md-6">
|
||||
<div class="card" style="border: 1px solid #ddd; padding: 15px;">
|
||||
<h5>Card Title 1</h5>
|
||||
<p>Your custom content here</p>
|
||||
<button class="btn btn-primary btn-sm">Action Button</button>
|
||||
</div>
|
||||
</div>
|
||||
<div class="col-md-6">
|
||||
<div class="card" style="border: 1px solid #ddd; padding: 15px;">
|
||||
<h5>Card Title 2</h5>
|
||||
<p>More custom content</p>
|
||||
<div class="progress" style="height: 20px;">
|
||||
<div class="progress-bar" style="width: 75%">75%</div>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
`;
|
||||
chart_container.html(custom_html);
|
||||
return;
|
||||
}
|
||||
// Call original render method for other charts
|
||||
return original_render.call(this, chart_data, chart_container);
|
||||
};
|
||||
});
|
||||
|
||||
@ -0,0 +1,13 @@
|
||||
{
|
||||
"creation": "2025-06-25 18:03:16.704998",
|
||||
"docstatus": 0,
|
||||
"doctype": "Dashboard Chart Source",
|
||||
"idx": 0,
|
||||
"modified": "2025-06-25 18:03:16.704998",
|
||||
"modified_by": "Administrator",
|
||||
"module": "Asset Lite",
|
||||
"name": "Active Map Widget",
|
||||
"owner": "Administrator",
|
||||
"source_name": "Active Map Widget",
|
||||
"timeseries": 0
|
||||
}
|
||||
0
asset_lite/asset_lite/doctype/__init__.py
Normal file
0
asset_lite/asset_lite/doctype/__init__.py
Normal file
0
asset_lite/asset_lite/doctype/agent/__init__.py
Normal file
0
asset_lite/asset_lite/doctype/agent/__init__.py
Normal file
8
asset_lite/asset_lite/doctype/agent/agent.js
Normal file
8
asset_lite/asset_lite/doctype/agent/agent.js
Normal file
@ -0,0 +1,8 @@
|
||||
// Copyright (c) 2024, seyfert and contributors
|
||||
// For license information, please see license.txt
|
||||
|
||||
// frappe.ui.form.on("Agent", {
|
||||
// refresh(frm) {
|
||||
|
||||
// },
|
||||
// });
|
||||
45
asset_lite/asset_lite/doctype/agent/agent.json
Normal file
45
asset_lite/asset_lite/doctype/agent/agent.json
Normal file
@ -0,0 +1,45 @@
|
||||
{
|
||||
"actions": [],
|
||||
"allow_import": 1,
|
||||
"allow_rename": 1,
|
||||
"autoname": "field:agent_name",
|
||||
"creation": "2024-12-13 14:37:38.780730",
|
||||
"doctype": "DocType",
|
||||
"engine": "InnoDB",
|
||||
"field_order": [
|
||||
"agent_name"
|
||||
],
|
||||
"fields": [
|
||||
{
|
||||
"fieldname": "agent_name",
|
||||
"fieldtype": "Data",
|
||||
"label": "Agent Name",
|
||||
"unique": 1
|
||||
}
|
||||
],
|
||||
"index_web_pages_for_search": 1,
|
||||
"links": [],
|
||||
"modified": "2024-12-13 15:15:47.447599",
|
||||
"modified_by": "Administrator",
|
||||
"module": "Asset Lite",
|
||||
"name": "Agent",
|
||||
"naming_rule": "By fieldname",
|
||||
"owner": "Administrator",
|
||||
"permissions": [
|
||||
{
|
||||
"create": 1,
|
||||
"delete": 1,
|
||||
"email": 1,
|
||||
"export": 1,
|
||||
"print": 1,
|
||||
"read": 1,
|
||||
"report": 1,
|
||||
"role": "System Manager",
|
||||
"share": 1,
|
||||
"write": 1
|
||||
}
|
||||
],
|
||||
"sort_field": "modified",
|
||||
"sort_order": "DESC",
|
||||
"states": []
|
||||
}
|
||||
9
asset_lite/asset_lite/doctype/agent/agent.py
Normal file
9
asset_lite/asset_lite/doctype/agent/agent.py
Normal file
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2024, seyfert and contributors
|
||||
# For license information, please see license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.model.document import Document
|
||||
|
||||
|
||||
class Agent(Document):
|
||||
pass
|
||||
9
asset_lite/asset_lite/doctype/agent/test_agent.py
Normal file
9
asset_lite/asset_lite/doctype/agent/test_agent.py
Normal file
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2024, seyfert and Contributors
|
||||
# See license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.tests.utils import FrappeTestCase
|
||||
|
||||
|
||||
class TestAgent(FrappeTestCase):
|
||||
pass
|
||||
@ -0,0 +1,8 @@
|
||||
// Copyright (c) 2025, seyfert and contributors
|
||||
// For license information, please see license.txt
|
||||
|
||||
// frappe.ui.form.on("Arabic Names", {
|
||||
// refresh(frm) {
|
||||
|
||||
// },
|
||||
// });
|
||||
50
asset_lite/asset_lite/doctype/arabic_names/arabic_names.json
Normal file
50
asset_lite/asset_lite/doctype/arabic_names/arabic_names.json
Normal file
@ -0,0 +1,50 @@
|
||||
{
|
||||
"actions": [],
|
||||
"allow_rename": 1,
|
||||
"autoname": "field:name1",
|
||||
"creation": "2025-02-07 16:56:53.486694",
|
||||
"doctype": "DocType",
|
||||
"engine": "InnoDB",
|
||||
"field_order": [
|
||||
"name1",
|
||||
"arabic_name"
|
||||
],
|
||||
"fields": [
|
||||
{
|
||||
"fieldname": "name1",
|
||||
"fieldtype": "Data",
|
||||
"label": "Name",
|
||||
"unique": 1
|
||||
},
|
||||
{
|
||||
"fieldname": "arabic_name",
|
||||
"fieldtype": "Data",
|
||||
"label": "Arabic Name"
|
||||
}
|
||||
],
|
||||
"index_web_pages_for_search": 1,
|
||||
"links": [],
|
||||
"modified": "2025-02-07 16:57:50.823039",
|
||||
"modified_by": "Administrator",
|
||||
"module": "Asset Lite",
|
||||
"name": "Arabic Names",
|
||||
"naming_rule": "By fieldname",
|
||||
"owner": "Administrator",
|
||||
"permissions": [
|
||||
{
|
||||
"create": 1,
|
||||
"delete": 1,
|
||||
"email": 1,
|
||||
"export": 1,
|
||||
"print": 1,
|
||||
"read": 1,
|
||||
"report": 1,
|
||||
"role": "System Manager",
|
||||
"share": 1,
|
||||
"write": 1
|
||||
}
|
||||
],
|
||||
"sort_field": "modified",
|
||||
"sort_order": "DESC",
|
||||
"states": []
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2025, seyfert and contributors
|
||||
# For license information, please see license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.model.document import Document
|
||||
|
||||
|
||||
class ArabicNames(Document):
|
||||
pass
|
||||
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2025, seyfert and Contributors
|
||||
# See license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.tests.utils import FrappeTestCase
|
||||
|
||||
|
||||
class TestArabicNames(FrappeTestCase):
|
||||
pass
|
||||
@ -0,0 +1,59 @@
|
||||
{
|
||||
"actions": [],
|
||||
"allow_rename": 1,
|
||||
"creation": "2025-08-26 21:00:34.676325",
|
||||
"default_view": "List",
|
||||
"doctype": "DocType",
|
||||
"editable_grid": 1,
|
||||
"engine": "InnoDB",
|
||||
"field_order": [
|
||||
"asset",
|
||||
"asset_name",
|
||||
"qty",
|
||||
"column_break_kbew",
|
||||
"return_inspection_committee"
|
||||
],
|
||||
"fields": [
|
||||
{
|
||||
"fieldname": "asset",
|
||||
"fieldtype": "Link",
|
||||
"label": "Asset",
|
||||
"options": "Asset"
|
||||
},
|
||||
{
|
||||
"fetch_from": "asset.asset_name",
|
||||
"fetch_if_empty": 1,
|
||||
"fieldname": "asset_name",
|
||||
"fieldtype": "Data",
|
||||
"label": "Asset Name"
|
||||
},
|
||||
{
|
||||
"default": "1",
|
||||
"fieldname": "qty",
|
||||
"fieldtype": "Float",
|
||||
"label": "Qty"
|
||||
},
|
||||
{
|
||||
"fieldname": "column_break_kbew",
|
||||
"fieldtype": "Column Break"
|
||||
},
|
||||
{
|
||||
"fieldname": "return_inspection_committee",
|
||||
"fieldtype": "Select",
|
||||
"label": "Return Inspection Committee",
|
||||
"options": "\nFor Repair\nFor Sale\nFor Disposal"
|
||||
}
|
||||
],
|
||||
"index_web_pages_for_search": 1,
|
||||
"istable": 1,
|
||||
"links": [],
|
||||
"modified": "2025-08-26 21:00:34.676325",
|
||||
"modified_by": "Administrator",
|
||||
"module": "Asset Lite",
|
||||
"name": "Asset Item Transfer",
|
||||
"owner": "Administrator",
|
||||
"permissions": [],
|
||||
"sort_field": "modified",
|
||||
"sort_order": "DESC",
|
||||
"states": []
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2025, seyfert and contributors
|
||||
# For license information, please see license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.model.document import Document
|
||||
|
||||
|
||||
class AssetItemTransfer(Document):
|
||||
pass
|
||||
8
asset_lite/asset_lite/doctype/asset_type/asset_type.js
Normal file
8
asset_lite/asset_lite/doctype/asset_type/asset_type.js
Normal file
@ -0,0 +1,8 @@
|
||||
// Copyright (c) 2024, seyfert and contributors
|
||||
// For license information, please see license.txt
|
||||
|
||||
// frappe.ui.form.on("Asset Type", {
|
||||
// refresh(frm) {
|
||||
|
||||
// },
|
||||
// });
|
||||
47
asset_lite/asset_lite/doctype/asset_type/asset_type.json
Normal file
47
asset_lite/asset_lite/doctype/asset_type/asset_type.json
Normal file
@ -0,0 +1,47 @@
|
||||
{
|
||||
"actions": [],
|
||||
"allow_rename": 1,
|
||||
"autoname": "field:asset_type",
|
||||
"creation": "2024-09-23 14:16:49.149093",
|
||||
"doctype": "DocType",
|
||||
"engine": "InnoDB",
|
||||
"field_order": [
|
||||
"asset_type"
|
||||
],
|
||||
"fields": [
|
||||
{
|
||||
"fieldname": "asset_type",
|
||||
"fieldtype": "Data",
|
||||
"in_list_view": 1,
|
||||
"label": "Asset Type",
|
||||
"reqd": 1,
|
||||
"unique": 1
|
||||
}
|
||||
],
|
||||
"index_web_pages_for_search": 1,
|
||||
"links": [],
|
||||
"modified": "2024-09-23 14:17:58.073254",
|
||||
"modified_by": "Administrator",
|
||||
"module": "Asset Lite",
|
||||
"name": "Asset Type",
|
||||
"naming_rule": "By fieldname",
|
||||
"owner": "Administrator",
|
||||
"permissions": [
|
||||
{
|
||||
"create": 1,
|
||||
"delete": 1,
|
||||
"email": 1,
|
||||
"export": 1,
|
||||
"print": 1,
|
||||
"read": 1,
|
||||
"report": 1,
|
||||
"role": "System Manager",
|
||||
"share": 1,
|
||||
"write": 1
|
||||
}
|
||||
],
|
||||
"quick_entry": 1,
|
||||
"sort_field": "modified",
|
||||
"sort_order": "DESC",
|
||||
"states": []
|
||||
}
|
||||
9
asset_lite/asset_lite/doctype/asset_type/asset_type.py
Normal file
9
asset_lite/asset_lite/doctype/asset_type/asset_type.py
Normal file
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2024, seyfert and contributors
|
||||
# For license information, please see license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.model.document import Document
|
||||
|
||||
|
||||
class AssetType(Document):
|
||||
pass
|
||||
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2024, seyfert and Contributors
|
||||
# See license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.tests.utils import FrappeTestCase
|
||||
|
||||
|
||||
class TestAssetType(FrappeTestCase):
|
||||
pass
|
||||
0
asset_lite/asset_lite/doctype/building/__init__.py
Normal file
0
asset_lite/asset_lite/doctype/building/__init__.py
Normal file
8
asset_lite/asset_lite/doctype/building/building.js
Normal file
8
asset_lite/asset_lite/doctype/building/building.js
Normal file
@ -0,0 +1,8 @@
|
||||
// Copyright (c) 2026, seyfert and contributors
|
||||
// For license information, please see license.txt
|
||||
|
||||
// frappe.ui.form.on("Building", {
|
||||
// refresh(frm) {
|
||||
|
||||
// },
|
||||
// });
|
||||
47
asset_lite/asset_lite/doctype/building/building.json
Normal file
47
asset_lite/asset_lite/doctype/building/building.json
Normal file
@ -0,0 +1,47 @@
|
||||
{
|
||||
"actions": [],
|
||||
"allow_import": 1,
|
||||
"allow_rename": 1,
|
||||
"autoname": "field:building",
|
||||
"creation": "2026-01-21 14:00:25.681969",
|
||||
"doctype": "DocType",
|
||||
"engine": "InnoDB",
|
||||
"field_order": [
|
||||
"building"
|
||||
],
|
||||
"fields": [
|
||||
{
|
||||
"fieldname": "building",
|
||||
"fieldtype": "Data",
|
||||
"label": "Building",
|
||||
"unique": 1
|
||||
}
|
||||
],
|
||||
"grid_page_length": 50,
|
||||
"index_web_pages_for_search": 1,
|
||||
"links": [],
|
||||
"modified": "2026-03-10 10:52:11.526339",
|
||||
"modified_by": "Administrator",
|
||||
"module": "Asset Lite",
|
||||
"name": "Building",
|
||||
"naming_rule": "By fieldname",
|
||||
"owner": "support@seeraarabia.com",
|
||||
"permissions": [
|
||||
{
|
||||
"create": 1,
|
||||
"delete": 1,
|
||||
"email": 1,
|
||||
"export": 1,
|
||||
"print": 1,
|
||||
"read": 1,
|
||||
"report": 1,
|
||||
"role": "System Manager",
|
||||
"share": 1,
|
||||
"write": 1
|
||||
}
|
||||
],
|
||||
"row_format": "Dynamic",
|
||||
"sort_field": "modified",
|
||||
"sort_order": "DESC",
|
||||
"states": []
|
||||
}
|
||||
9
asset_lite/asset_lite/doctype/building/building.py
Normal file
9
asset_lite/asset_lite/doctype/building/building.py
Normal file
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2026, seyfert and contributors
|
||||
# For license information, please see license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.model.document import Document
|
||||
|
||||
|
||||
class Building(Document):
|
||||
pass
|
||||
9
asset_lite/asset_lite/doctype/building/test_building.py
Normal file
9
asset_lite/asset_lite/doctype/building/test_building.py
Normal file
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2026, seyfert and Contributors
|
||||
# See license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.tests.utils import FrappeTestCase
|
||||
|
||||
|
||||
class TestBuilding(FrappeTestCase):
|
||||
pass
|
||||
0
asset_lite/asset_lite/doctype/city/__init__.py
Normal file
0
asset_lite/asset_lite/doctype/city/__init__.py
Normal file
8
asset_lite/asset_lite/doctype/city/city.js
Normal file
8
asset_lite/asset_lite/doctype/city/city.js
Normal file
@ -0,0 +1,8 @@
|
||||
// Copyright (c) 2025, seyfert and contributors
|
||||
// For license information, please see license.txt
|
||||
|
||||
// frappe.ui.form.on("City", {
|
||||
// refresh(frm) {
|
||||
|
||||
// },
|
||||
// });
|
||||
44
asset_lite/asset_lite/doctype/city/city.json
Normal file
44
asset_lite/asset_lite/doctype/city/city.json
Normal file
@ -0,0 +1,44 @@
|
||||
{
|
||||
"actions": [],
|
||||
"allow_rename": 1,
|
||||
"autoname": "field:city",
|
||||
"creation": "2025-08-26 15:20:17.013649",
|
||||
"doctype": "DocType",
|
||||
"engine": "InnoDB",
|
||||
"field_order": [
|
||||
"city"
|
||||
],
|
||||
"fields": [
|
||||
{
|
||||
"fieldname": "city",
|
||||
"fieldtype": "Data",
|
||||
"label": "City",
|
||||
"unique": 1
|
||||
}
|
||||
],
|
||||
"index_web_pages_for_search": 1,
|
||||
"links": [],
|
||||
"modified": "2025-08-26 20:43:50.686274",
|
||||
"modified_by": "Administrator",
|
||||
"module": "Asset Lite",
|
||||
"name": "City",
|
||||
"naming_rule": "By fieldname",
|
||||
"owner": "Administrator",
|
||||
"permissions": [
|
||||
{
|
||||
"create": 1,
|
||||
"delete": 1,
|
||||
"email": 1,
|
||||
"export": 1,
|
||||
"print": 1,
|
||||
"read": 1,
|
||||
"report": 1,
|
||||
"role": "System Manager",
|
||||
"share": 1,
|
||||
"write": 1
|
||||
}
|
||||
],
|
||||
"sort_field": "modified",
|
||||
"sort_order": "DESC",
|
||||
"states": []
|
||||
}
|
||||
9
asset_lite/asset_lite/doctype/city/city.py
Normal file
9
asset_lite/asset_lite/doctype/city/city.py
Normal file
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2025, seyfert and contributors
|
||||
# For license information, please see license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.model.document import Document
|
||||
|
||||
|
||||
class City(Document):
|
||||
pass
|
||||
9
asset_lite/asset_lite/doctype/city/test_city.py
Normal file
9
asset_lite/asset_lite/doctype/city/test_city.py
Normal file
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2025, seyfert and Contributors
|
||||
# See license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.tests.utils import FrappeTestCase
|
||||
|
||||
|
||||
class TestCity(FrappeTestCase):
|
||||
pass
|
||||
@ -0,0 +1,8 @@
|
||||
// Copyright (c) 2026, seyfert and contributors
|
||||
// For license information, please see license.txt
|
||||
|
||||
// frappe.ui.form.on("Delete Request", {
|
||||
// refresh(frm) {
|
||||
|
||||
// },
|
||||
// });
|
||||
125
asset_lite/asset_lite/doctype/delete_request/delete_request.json
Normal file
125
asset_lite/asset_lite/doctype/delete_request/delete_request.json
Normal file
@ -0,0 +1,125 @@
|
||||
{
|
||||
"actions": [],
|
||||
"allow_rename": 1,
|
||||
"autoname": "format:{target_doctype}-{target_name}",
|
||||
"creation": "2026-02-18 11:23:18.627887",
|
||||
"doctype": "DocType",
|
||||
"engine": "InnoDB",
|
||||
"field_order": [
|
||||
"target_doctype",
|
||||
"target_display",
|
||||
"department",
|
||||
"status",
|
||||
"column_break_nhyd",
|
||||
"target_name",
|
||||
"reason",
|
||||
"requested_by",
|
||||
"section_break_lwex",
|
||||
"supervisor_comment",
|
||||
"column_break_wsat",
|
||||
"cluster_manager_comment",
|
||||
"amended_from"
|
||||
],
|
||||
"fields": [
|
||||
{
|
||||
"fieldname": "target_doctype",
|
||||
"fieldtype": "Link",
|
||||
"label": "Target Doctype",
|
||||
"options": "DocType"
|
||||
},
|
||||
{
|
||||
"fieldname": "department",
|
||||
"fieldtype": "Link",
|
||||
"label": "Department",
|
||||
"options": "Issue Type"
|
||||
},
|
||||
{
|
||||
"allow_on_submit": 1,
|
||||
"fieldname": "status",
|
||||
"fieldtype": "Select",
|
||||
"label": "Status",
|
||||
"options": "Pending\nApproved\nRejected"
|
||||
},
|
||||
{
|
||||
"fieldname": "column_break_nhyd",
|
||||
"fieldtype": "Column Break"
|
||||
},
|
||||
{
|
||||
"fieldname": "target_name",
|
||||
"fieldtype": "Data",
|
||||
"label": "Target Name"
|
||||
},
|
||||
{
|
||||
"fieldname": "reason",
|
||||
"fieldtype": "Data",
|
||||
"label": "Reason"
|
||||
},
|
||||
{
|
||||
"fieldname": "requested_by",
|
||||
"fieldtype": "Link",
|
||||
"label": "Requested By",
|
||||
"options": "User"
|
||||
},
|
||||
{
|
||||
"fieldname": "section_break_lwex",
|
||||
"fieldtype": "Section Break"
|
||||
},
|
||||
{
|
||||
"fieldname": "supervisor_comment",
|
||||
"fieldtype": "Small Text",
|
||||
"label": "Supervisor Comment"
|
||||
},
|
||||
{
|
||||
"fieldname": "column_break_wsat",
|
||||
"fieldtype": "Column Break"
|
||||
},
|
||||
{
|
||||
"fieldname": "cluster_manager_comment",
|
||||
"fieldtype": "Small Text",
|
||||
"label": "CM Comment"
|
||||
},
|
||||
{
|
||||
"fieldname": "target_display",
|
||||
"fieldtype": "Data",
|
||||
"label": "Target Display"
|
||||
},
|
||||
{
|
||||
"fieldname": "amended_from",
|
||||
"fieldtype": "Link",
|
||||
"label": "Amended From",
|
||||
"no_copy": 1,
|
||||
"options": "Delete Request",
|
||||
"print_hide": 1,
|
||||
"read_only": 1,
|
||||
"search_index": 1
|
||||
}
|
||||
],
|
||||
"grid_page_length": 50,
|
||||
"index_web_pages_for_search": 1,
|
||||
"is_submittable": 1,
|
||||
"links": [],
|
||||
"modified": "2026-02-18 15:22:54.215648",
|
||||
"modified_by": "Administrator",
|
||||
"module": "Asset Lite",
|
||||
"name": "Delete Request",
|
||||
"naming_rule": "Expression",
|
||||
"owner": "Administrator",
|
||||
"permissions": [
|
||||
{
|
||||
"create": 1,
|
||||
"delete": 1,
|
||||
"email": 1,
|
||||
"export": 1,
|
||||
"print": 1,
|
||||
"read": 1,
|
||||
"report": 1,
|
||||
"role": "System Manager",
|
||||
"share": 1,
|
||||
"write": 1
|
||||
}
|
||||
],
|
||||
"row_format": "Dynamic",
|
||||
"sort_field": "modified",
|
||||
"sort_order": "DESC",
|
||||
"states": []
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2026, seyfert and contributors
|
||||
# For license information, please see license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.model.document import Document
|
||||
|
||||
|
||||
class DeleteRequest(Document):
|
||||
pass
|
||||
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2026, seyfert and Contributors
|
||||
# See license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.tests.utils import FrappeTestCase
|
||||
|
||||
|
||||
class TestDeleteRequest(FrappeTestCase):
|
||||
pass
|
||||
8
asset_lite/asset_lite/doctype/ecri_umdns/ecri_umdns.js
Normal file
8
asset_lite/asset_lite/doctype/ecri_umdns/ecri_umdns.js
Normal file
@ -0,0 +1,8 @@
|
||||
// Copyright (c) 2024, seyfert and contributors
|
||||
// For license information, please see license.txt
|
||||
|
||||
// frappe.ui.form.on("ECRI UMDNS", {
|
||||
// refresh(frm) {
|
||||
|
||||
// },
|
||||
// });
|
||||
51
asset_lite/asset_lite/doctype/ecri_umdns/ecri_umdns.json
Normal file
51
asset_lite/asset_lite/doctype/ecri_umdns/ecri_umdns.json
Normal file
@ -0,0 +1,51 @@
|
||||
{
|
||||
"actions": [],
|
||||
"allow_import": 1,
|
||||
"allow_rename": 1,
|
||||
"autoname": "field:ecri",
|
||||
"creation": "2024-12-03 14:43:40.910282",
|
||||
"doctype": "DocType",
|
||||
"engine": "InnoDB",
|
||||
"field_order": [
|
||||
"ecri",
|
||||
"device_name"
|
||||
],
|
||||
"fields": [
|
||||
{
|
||||
"fieldname": "ecri",
|
||||
"fieldtype": "Data",
|
||||
"label": "ECRI",
|
||||
"unique": 1
|
||||
},
|
||||
{
|
||||
"fieldname": "device_name",
|
||||
"fieldtype": "Data",
|
||||
"label": "Device Name"
|
||||
}
|
||||
],
|
||||
"index_web_pages_for_search": 1,
|
||||
"links": [],
|
||||
"modified": "2024-12-03 18:43:19.609779",
|
||||
"modified_by": "Administrator",
|
||||
"module": "Asset Lite",
|
||||
"name": "ECRI UMDNS",
|
||||
"naming_rule": "By fieldname",
|
||||
"owner": "Administrator",
|
||||
"permissions": [
|
||||
{
|
||||
"create": 1,
|
||||
"delete": 1,
|
||||
"email": 1,
|
||||
"export": 1,
|
||||
"print": 1,
|
||||
"read": 1,
|
||||
"report": 1,
|
||||
"role": "System Manager",
|
||||
"share": 1,
|
||||
"write": 1
|
||||
}
|
||||
],
|
||||
"sort_field": "modified",
|
||||
"sort_order": "DESC",
|
||||
"states": []
|
||||
}
|
||||
9
asset_lite/asset_lite/doctype/ecri_umdns/ecri_umdns.py
Normal file
9
asset_lite/asset_lite/doctype/ecri_umdns/ecri_umdns.py
Normal file
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2024, seyfert and contributors
|
||||
# For license information, please see license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.model.document import Document
|
||||
|
||||
|
||||
class ECRIUMDNS(Document):
|
||||
pass
|
||||
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2024, seyfert and Contributors
|
||||
# See license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.tests.utils import FrappeTestCase
|
||||
|
||||
|
||||
class TestECRIUMDNS(FrappeTestCase):
|
||||
pass
|
||||
@ -0,0 +1,8 @@
|
||||
// Copyright (c) 2025, seyfert and contributors
|
||||
// For license information, please see license.txt
|
||||
|
||||
// frappe.ui.form.on("Extension Directory", {
|
||||
// refresh(frm) {
|
||||
|
||||
// },
|
||||
// });
|
||||
@ -0,0 +1,47 @@
|
||||
{
|
||||
"actions": [],
|
||||
"allow_import": 1,
|
||||
"allow_rename": 1,
|
||||
"autoname": "field:extension_number",
|
||||
"creation": "2025-12-12 13:47:32.707063",
|
||||
"doctype": "DocType",
|
||||
"engine": "InnoDB",
|
||||
"field_order": [
|
||||
"extension_number"
|
||||
],
|
||||
"fields": [
|
||||
{
|
||||
"fieldname": "extension_number",
|
||||
"fieldtype": "Data",
|
||||
"label": "Extension Number",
|
||||
"unique": 1
|
||||
}
|
||||
],
|
||||
"grid_page_length": 50,
|
||||
"index_web_pages_for_search": 1,
|
||||
"links": [],
|
||||
"modified": "2026-01-12 15:40:06.059968",
|
||||
"modified_by": "support@seeraarabia.com",
|
||||
"module": "Asset Lite",
|
||||
"name": "Extension Directory",
|
||||
"naming_rule": "By fieldname",
|
||||
"owner": "Administrator",
|
||||
"permissions": [
|
||||
{
|
||||
"create": 1,
|
||||
"delete": 1,
|
||||
"email": 1,
|
||||
"export": 1,
|
||||
"print": 1,
|
||||
"read": 1,
|
||||
"report": 1,
|
||||
"role": "System Manager",
|
||||
"share": 1,
|
||||
"write": 1
|
||||
}
|
||||
],
|
||||
"row_format": "Dynamic",
|
||||
"sort_field": "modified",
|
||||
"sort_order": "DESC",
|
||||
"states": []
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2025, seyfert and contributors
|
||||
# For license information, please see license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.model.document import Document
|
||||
|
||||
|
||||
class ExtensionDirectory(Document):
|
||||
pass
|
||||
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2025, seyfert and Contributors
|
||||
# See license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.tests.utils import FrappeTestCase
|
||||
|
||||
|
||||
class TestExtensionDirectory(FrappeTestCase):
|
||||
pass
|
||||
0
asset_lite/asset_lite/doctype/feedback/__init__.py
Normal file
0
asset_lite/asset_lite/doctype/feedback/__init__.py
Normal file
8
asset_lite/asset_lite/doctype/feedback/feedback.js
Normal file
8
asset_lite/asset_lite/doctype/feedback/feedback.js
Normal file
@ -0,0 +1,8 @@
|
||||
// Copyright (c) 2025, seyfert and contributors
|
||||
// For license information, please see license.txt
|
||||
|
||||
// frappe.ui.form.on("Feedback", {
|
||||
// refresh(frm) {
|
||||
|
||||
// },
|
||||
// });
|
||||
77
asset_lite/asset_lite/doctype/feedback/feedback.json
Normal file
77
asset_lite/asset_lite/doctype/feedback/feedback.json
Normal file
@ -0,0 +1,77 @@
|
||||
{
|
||||
"actions": [],
|
||||
"allow_rename": 1,
|
||||
"creation": "2025-03-05 19:53:51.796362",
|
||||
"doctype": "DocType",
|
||||
"engine": "InnoDB",
|
||||
"field_order": [
|
||||
"work_order",
|
||||
"column_break_eytf",
|
||||
"feedback_by",
|
||||
"section_break_rvtb",
|
||||
"parameters",
|
||||
"section_break_zmrx",
|
||||
"overall"
|
||||
],
|
||||
"fields": [
|
||||
{
|
||||
"fieldname": "work_order",
|
||||
"fieldtype": "Link",
|
||||
"label": "Work Order",
|
||||
"options": "Work_Order"
|
||||
},
|
||||
{
|
||||
"fieldname": "column_break_eytf",
|
||||
"fieldtype": "Column Break"
|
||||
},
|
||||
{
|
||||
"fieldname": "feedback_by",
|
||||
"fieldtype": "Link",
|
||||
"label": "Feedback by",
|
||||
"options": "User"
|
||||
},
|
||||
{
|
||||
"fieldname": "section_break_rvtb",
|
||||
"fieldtype": "Section Break"
|
||||
},
|
||||
{
|
||||
"fieldname": "parameters",
|
||||
"fieldtype": "Table",
|
||||
"label": "Parameters",
|
||||
"options": "Feedback Table"
|
||||
},
|
||||
{
|
||||
"fieldname": "section_break_zmrx",
|
||||
"fieldtype": "Section Break"
|
||||
},
|
||||
{
|
||||
"fieldname": "overall",
|
||||
"fieldtype": "Rating",
|
||||
"label": "Overall"
|
||||
}
|
||||
],
|
||||
"index_web_pages_for_search": 1,
|
||||
"links": [],
|
||||
"modified": "2025-03-05 19:56:58.056262",
|
||||
"modified_by": "Administrator",
|
||||
"module": "Asset Lite",
|
||||
"name": "Feedback",
|
||||
"owner": "Administrator",
|
||||
"permissions": [
|
||||
{
|
||||
"create": 1,
|
||||
"delete": 1,
|
||||
"email": 1,
|
||||
"export": 1,
|
||||
"print": 1,
|
||||
"read": 1,
|
||||
"report": 1,
|
||||
"role": "System Manager",
|
||||
"share": 1,
|
||||
"write": 1
|
||||
}
|
||||
],
|
||||
"sort_field": "modified",
|
||||
"sort_order": "DESC",
|
||||
"states": []
|
||||
}
|
||||
28
asset_lite/asset_lite/doctype/feedback/feedback.py
Normal file
28
asset_lite/asset_lite/doctype/feedback/feedback.py
Normal file
@ -0,0 +1,28 @@
|
||||
# Copyright (c) 2025, seyfert and contributors
|
||||
# For license information, please see license.txt
|
||||
|
||||
import frappe
|
||||
from frappe.model.document import Document
|
||||
|
||||
|
||||
class Feedback(Document):
|
||||
def validate(self):
|
||||
self.calculate_overall()
|
||||
|
||||
def on_update(self):
|
||||
self.sync_work_order_rating()
|
||||
|
||||
def calculate_overall(self):
|
||||
rated = [row.rating for row in self.parameters if row.rating]
|
||||
self.overall = round(sum(rated) / len(rated), 2) if rated else 0
|
||||
|
||||
def sync_work_order_rating(self):
|
||||
if self.work_order and self.overall:
|
||||
frappe.db.set_value(
|
||||
"Work_Order",
|
||||
self.work_order,
|
||||
{
|
||||
"feedback": self.name,
|
||||
"feedback_rating": self.overall,
|
||||
},
|
||||
)
|
||||
9
asset_lite/asset_lite/doctype/feedback/test_feedback.py
Normal file
9
asset_lite/asset_lite/doctype/feedback/test_feedback.py
Normal file
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2025, seyfert and Contributors
|
||||
# See license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.tests.utils import FrappeTestCase
|
||||
|
||||
|
||||
class TestFeedback(FrappeTestCase):
|
||||
pass
|
||||
@ -0,0 +1,8 @@
|
||||
// Copyright (c) 2026, seyfert and contributors
|
||||
// For license information, please see license.txt
|
||||
|
||||
// frappe.ui.form.on("Feedback Parameters", {
|
||||
// refresh(frm) {
|
||||
|
||||
// },
|
||||
// });
|
||||
@ -0,0 +1,41 @@
|
||||
{
|
||||
"actions": [],
|
||||
"allow_rename": 1,
|
||||
"creation": "2026-02-05 16:07:06.424217",
|
||||
"doctype": "DocType",
|
||||
"engine": "InnoDB",
|
||||
"field_order": [
|
||||
"section_break_et0g"
|
||||
],
|
||||
"fields": [
|
||||
{
|
||||
"fieldname": "section_break_et0g",
|
||||
"fieldtype": "Section Break"
|
||||
}
|
||||
],
|
||||
"grid_page_length": 50,
|
||||
"index_web_pages_for_search": 1,
|
||||
"issingle": 1,
|
||||
"links": [],
|
||||
"modified": "2026-02-05 16:07:06.424217",
|
||||
"modified_by": "Administrator",
|
||||
"module": "Asset Lite",
|
||||
"name": "Feedback Parameters",
|
||||
"owner": "Administrator",
|
||||
"permissions": [
|
||||
{
|
||||
"create": 1,
|
||||
"delete": 1,
|
||||
"email": 1,
|
||||
"print": 1,
|
||||
"read": 1,
|
||||
"role": "System Manager",
|
||||
"share": 1,
|
||||
"write": 1
|
||||
}
|
||||
],
|
||||
"row_format": "Dynamic",
|
||||
"sort_field": "modified",
|
||||
"sort_order": "DESC",
|
||||
"states": []
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2026, seyfert and contributors
|
||||
# For license information, please see license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.model.document import Document
|
||||
|
||||
|
||||
class FeedbackParameters(Document):
|
||||
pass
|
||||
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2026, seyfert and Contributors
|
||||
# See license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.tests.utils import FrappeTestCase
|
||||
|
||||
|
||||
class TestFeedbackParameters(FrappeTestCase):
|
||||
pass
|
||||
@ -0,0 +1,44 @@
|
||||
{
|
||||
"actions": [],
|
||||
"allow_rename": 1,
|
||||
"creation": "2025-03-05 20:36:14.651301",
|
||||
"doctype": "DocType",
|
||||
"editable_grid": 1,
|
||||
"engine": "InnoDB",
|
||||
"field_order": [
|
||||
"parameter",
|
||||
"rating",
|
||||
"feedback"
|
||||
],
|
||||
"fields": [
|
||||
{
|
||||
"fieldname": "parameter",
|
||||
"fieldtype": "Data",
|
||||
"label": "Parameter"
|
||||
},
|
||||
{
|
||||
"fieldname": "rating",
|
||||
"fieldtype": "Rating",
|
||||
"in_list_view": 1,
|
||||
"label": "Rating",
|
||||
"reqd": 1
|
||||
},
|
||||
{
|
||||
"fieldname": "feedback",
|
||||
"fieldtype": "Text",
|
||||
"label": "Feedback"
|
||||
}
|
||||
],
|
||||
"index_web_pages_for_search": 1,
|
||||
"istable": 1,
|
||||
"links": [],
|
||||
"modified": "2025-03-05 20:49:43.458939",
|
||||
"modified_by": "Administrator",
|
||||
"module": "Asset Lite",
|
||||
"name": "Feedback Table",
|
||||
"owner": "Administrator",
|
||||
"permissions": [],
|
||||
"sort_field": "modified",
|
||||
"sort_order": "DESC",
|
||||
"states": []
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2025, seyfert and contributors
|
||||
# For license information, please see license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.model.document import Document
|
||||
|
||||
|
||||
class FeedbackTable(Document):
|
||||
pass
|
||||
@ -0,0 +1,8 @@
|
||||
// Copyright (c) 2026, seyfert and contributors
|
||||
// For license information, please see license.txt
|
||||
|
||||
// frappe.ui.form.on("Infrastructure Location", {
|
||||
// refresh(frm) {
|
||||
|
||||
// },
|
||||
// });
|
||||
@ -0,0 +1,97 @@
|
||||
{
|
||||
"actions": [],
|
||||
"allow_import": 1,
|
||||
"allow_rename": 1,
|
||||
"autoname": "format:{building}-{department}-{room_no}-{location}",
|
||||
"creation": "2026-02-02 09:53:38.751717",
|
||||
"doctype": "DocType",
|
||||
"engine": "InnoDB",
|
||||
"field_order": [
|
||||
"building",
|
||||
"room_no",
|
||||
"check_xqxx",
|
||||
"column_break_jbgn",
|
||||
"department",
|
||||
"location"
|
||||
],
|
||||
"fields": [
|
||||
{
|
||||
"fieldname": "building",
|
||||
"fieldtype": "Link",
|
||||
"in_global_search": 1,
|
||||
"in_list_view": 1,
|
||||
"in_standard_filter": 1,
|
||||
"label": "Building",
|
||||
"options": "Building"
|
||||
},
|
||||
{
|
||||
"fieldname": "room_no",
|
||||
"fieldtype": "Link",
|
||||
"in_filter": 1,
|
||||
"in_global_search": 1,
|
||||
"in_list_view": 1,
|
||||
"in_standard_filter": 1,
|
||||
"label": "Room No",
|
||||
"options": "Room"
|
||||
},
|
||||
{
|
||||
"fieldname": "column_break_jbgn",
|
||||
"fieldtype": "Column Break"
|
||||
},
|
||||
{
|
||||
"fieldname": "department",
|
||||
"fieldtype": "Link",
|
||||
"in_filter": 1,
|
||||
"in_global_search": 1,
|
||||
"in_list_view": 1,
|
||||
"in_standard_filter": 1,
|
||||
"label": "Department",
|
||||
"options": "Department"
|
||||
},
|
||||
{
|
||||
"fieldname": "location",
|
||||
"fieldtype": "Link",
|
||||
"in_filter": 1,
|
||||
"in_global_search": 1,
|
||||
"in_list_view": 1,
|
||||
"in_standard_filter": 1,
|
||||
"label": "Location",
|
||||
"options": "Location"
|
||||
},
|
||||
{
|
||||
"default": "0",
|
||||
"fieldname": "check_xqxx",
|
||||
"fieldtype": "Check",
|
||||
"hidden": 1,
|
||||
"label": "enable"
|
||||
}
|
||||
],
|
||||
"grid_page_length": 50,
|
||||
"index_web_pages_for_search": 1,
|
||||
"links": [],
|
||||
"modified": "2026-03-02 16:28:35.630556",
|
||||
"modified_by": "support@seeraarabia.com",
|
||||
"module": "Asset Lite",
|
||||
"name": "Infrastructure Location",
|
||||
"naming_rule": "Expression",
|
||||
"owner": "Administrator",
|
||||
"permissions": [
|
||||
{
|
||||
"create": 1,
|
||||
"delete": 1,
|
||||
"email": 1,
|
||||
"export": 1,
|
||||
"print": 1,
|
||||
"read": 1,
|
||||
"report": 1,
|
||||
"role": "System Manager",
|
||||
"share": 1,
|
||||
"write": 1
|
||||
}
|
||||
],
|
||||
"row_format": "Dynamic",
|
||||
"sort_field": "modified",
|
||||
"sort_order": "DESC",
|
||||
"states": [],
|
||||
"track_changes": 1
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2026, seyfert and contributors
|
||||
# For license information, please see license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.model.document import Document
|
||||
|
||||
|
||||
class InfrastructureLocation(Document):
|
||||
pass
|
||||
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2026, seyfert and Contributors
|
||||
# See license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.tests.utils import FrappeTestCase
|
||||
|
||||
|
||||
class TestInfrastructureLocation(FrappeTestCase):
|
||||
pass
|
||||
8
asset_lite/asset_lite/doctype/inspection/inspection.js
Normal file
8
asset_lite/asset_lite/doctype/inspection/inspection.js
Normal file
@ -0,0 +1,8 @@
|
||||
// Copyright (c) 2026, seyfert and contributors
|
||||
// For license information, please see license.txt
|
||||
|
||||
// frappe.ui.form.on("Inspection", {
|
||||
// refresh(frm) {
|
||||
|
||||
// },
|
||||
// });
|
||||
222
asset_lite/asset_lite/doctype/inspection/inspection.json
Normal file
222
asset_lite/asset_lite/doctype/inspection/inspection.json
Normal file
@ -0,0 +1,222 @@
|
||||
{
|
||||
"actions": [],
|
||||
"allow_rename": 1,
|
||||
"autoname": "format:INS-{YYYY}-{###}",
|
||||
"creation": "2026-01-06 12:12:55.013069",
|
||||
"doctype": "DocType",
|
||||
"engine": "InnoDB",
|
||||
"field_order": [
|
||||
"inspection_type",
|
||||
"work_order_type",
|
||||
"inspection_date",
|
||||
"target_closure_date",
|
||||
"directed_to_responsible",
|
||||
"linked_corrective_wo_no",
|
||||
"status1",
|
||||
"attachment",
|
||||
"custom_delete_status",
|
||||
"column_break_wcyc",
|
||||
"status",
|
||||
"requested_by",
|
||||
"department",
|
||||
"location",
|
||||
"assigned_engineer",
|
||||
"assigned_technician",
|
||||
"technician_name",
|
||||
"technician_department",
|
||||
"extension_no",
|
||||
"attachment_on_close",
|
||||
"amended_from",
|
||||
"section_break_ajvn",
|
||||
"observation_note",
|
||||
"column_break_sfev",
|
||||
"technical_response"
|
||||
],
|
||||
"fields": [
|
||||
{
|
||||
"fieldname": "inspection_type",
|
||||
"fieldtype": "Select",
|
||||
"label": "Inspection Type",
|
||||
"options": "\nSafety Inspection\nInspection"
|
||||
},
|
||||
{
|
||||
"fieldname": "work_order_type",
|
||||
"fieldtype": "Link",
|
||||
"label": "Work Order Type",
|
||||
"options": "Issue Type"
|
||||
},
|
||||
{
|
||||
"fieldname": "inspection_date",
|
||||
"fieldtype": "Date",
|
||||
"label": "Inspection Date"
|
||||
},
|
||||
{
|
||||
"fieldname": "target_closure_date",
|
||||
"fieldtype": "Date",
|
||||
"label": " Target Closure Date"
|
||||
},
|
||||
{
|
||||
"fieldname": "directed_to_responsible",
|
||||
"fieldtype": "Data",
|
||||
"label": "Directed To (Responsible)"
|
||||
},
|
||||
{
|
||||
"fieldname": "linked_corrective_wo_no",
|
||||
"fieldtype": "Link",
|
||||
"label": "Linked Corrective WO No",
|
||||
"options": "Work_Order"
|
||||
},
|
||||
{
|
||||
"fieldname": "status1",
|
||||
"fieldtype": "Select",
|
||||
"hidden": 1,
|
||||
"label": " Status1",
|
||||
"options": "\nOpen\nIn Progress\nClosed"
|
||||
},
|
||||
{
|
||||
"fieldname": "attachment",
|
||||
"fieldtype": "Attach",
|
||||
"in_list_view": 1,
|
||||
"label": "Attachment on Open"
|
||||
},
|
||||
{
|
||||
"allow_on_submit": 1,
|
||||
"fieldname": "custom_delete_status",
|
||||
"fieldtype": "Select",
|
||||
"label": "Delete Status",
|
||||
"options": "\nDelete Request With Supervisor\nDelete Request With CM\nDeleted"
|
||||
},
|
||||
{
|
||||
"fieldname": "column_break_wcyc",
|
||||
"fieldtype": "Column Break"
|
||||
},
|
||||
{
|
||||
"fieldname": "status",
|
||||
"fieldtype": "Select",
|
||||
"label": " Status",
|
||||
"options": "\nOpen\nIn Progress\nPending Review\nClosed",
|
||||
"read_only": 1
|
||||
},
|
||||
{
|
||||
"fieldname": "requested_by",
|
||||
"fieldtype": "Data",
|
||||
"label": "Requested By"
|
||||
},
|
||||
{
|
||||
"fieldname": "department",
|
||||
"fieldtype": "Link",
|
||||
"label": "Department",
|
||||
"options": "Department"
|
||||
},
|
||||
{
|
||||
"fieldname": "location",
|
||||
"fieldtype": "Link",
|
||||
"label": "Location",
|
||||
"options": "Location"
|
||||
},
|
||||
{
|
||||
"fieldname": "assigned_technician",
|
||||
"fieldtype": "Link",
|
||||
"label": "Assigned Technician",
|
||||
"options": "User"
|
||||
},
|
||||
{
|
||||
"fetch_from": "assigned_technician.full_name",
|
||||
"fetch_if_empty": 1,
|
||||
"fieldname": "technician_name",
|
||||
"fieldtype": "Data",
|
||||
"label": "Technician Name",
|
||||
"read_only": 1
|
||||
},
|
||||
{
|
||||
"fieldname": "technician_department",
|
||||
"fieldtype": "Link",
|
||||
"label": "Technician Department",
|
||||
"options": "Technical Department"
|
||||
},
|
||||
{
|
||||
"fieldname": "extension_no",
|
||||
"fieldtype": "Link",
|
||||
"in_list_view": 1,
|
||||
"label": "Extension No",
|
||||
"options": "Extension Directory",
|
||||
"reqd": 1
|
||||
},
|
||||
{
|
||||
"fetch_from": "linked_corrective_wo_no.custom_attachment_on_close",
|
||||
"fetch_if_empty": 1,
|
||||
"fieldname": "attachment_on_close",
|
||||
"fieldtype": "Attach",
|
||||
"in_list_view": 1,
|
||||
"label": "Attachment on Close"
|
||||
},
|
||||
{
|
||||
"fieldname": "amended_from",
|
||||
"fieldtype": "Link",
|
||||
"label": "Amended From",
|
||||
"no_copy": 1,
|
||||
"options": "Inspection",
|
||||
"print_hide": 1,
|
||||
"read_only": 1,
|
||||
"search_index": 1
|
||||
},
|
||||
{
|
||||
"fieldname": "section_break_ajvn",
|
||||
"fieldtype": "Section Break"
|
||||
},
|
||||
{
|
||||
"fieldname": "observation_note",
|
||||
"fieldtype": "Small Text",
|
||||
"label": " Observation / Note"
|
||||
},
|
||||
{
|
||||
"fieldname": "column_break_sfev",
|
||||
"fieldtype": "Column Break"
|
||||
},
|
||||
{
|
||||
"fieldname": "technical_response",
|
||||
"fieldtype": "Small Text",
|
||||
"label": "Technical Response"
|
||||
},
|
||||
{
|
||||
"fieldname": "assigned_engineer",
|
||||
"fieldtype": "Link",
|
||||
"label": "Assigned Engineer",
|
||||
"options": "User"
|
||||
}
|
||||
],
|
||||
"grid_page_length": 50,
|
||||
"index_web_pages_for_search": 1,
|
||||
"is_submittable": 1,
|
||||
"links": [
|
||||
{
|
||||
"link_doctype": "Work_Order",
|
||||
"link_fieldname": "inspection"
|
||||
}
|
||||
],
|
||||
"modified": "2026-04-06 10:47:28.259269",
|
||||
"modified_by": "Administrator",
|
||||
"module": "Asset Lite",
|
||||
"name": "Inspection",
|
||||
"naming_rule": "Expression",
|
||||
"owner": "support@seeraarabia.com",
|
||||
"permissions": [
|
||||
{
|
||||
"create": 1,
|
||||
"delete": 1,
|
||||
"email": 1,
|
||||
"export": 1,
|
||||
"print": 1,
|
||||
"read": 1,
|
||||
"report": 1,
|
||||
"role": "System Manager",
|
||||
"share": 1,
|
||||
"write": 1
|
||||
}
|
||||
],
|
||||
"row_format": "Dynamic",
|
||||
"sort_field": "modified",
|
||||
"sort_order": "DESC",
|
||||
"states": [],
|
||||
"track_changes": 1
|
||||
}
|
||||
9
asset_lite/asset_lite/doctype/inspection/inspection.py
Normal file
9
asset_lite/asset_lite/doctype/inspection/inspection.py
Normal file
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2026, seyfert and contributors
|
||||
# For license information, please see license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.model.document import Document
|
||||
|
||||
|
||||
class Inspection(Document):
|
||||
pass
|
||||
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2026, seyfert and Contributors
|
||||
# See license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.tests.utils import FrappeTestCase
|
||||
|
||||
|
||||
class TestInspection(FrappeTestCase):
|
||||
pass
|
||||
@ -0,0 +1,64 @@
|
||||
{
|
||||
"actions": [],
|
||||
"allow_rename": 1,
|
||||
"creation": "2025-08-26 21:01:28.397119",
|
||||
"doctype": "DocType",
|
||||
"editable_grid": 1,
|
||||
"engine": "InnoDB",
|
||||
"field_order": [
|
||||
"item",
|
||||
"qty",
|
||||
"uom",
|
||||
"column_break_gcjw",
|
||||
"item_name",
|
||||
"return_inspection_committee"
|
||||
],
|
||||
"fields": [
|
||||
{
|
||||
"fieldname": "item",
|
||||
"fieldtype": "Link",
|
||||
"label": "Item",
|
||||
"options": "Item"
|
||||
},
|
||||
{
|
||||
"fieldname": "qty",
|
||||
"fieldtype": "Float",
|
||||
"label": "Qty"
|
||||
},
|
||||
{
|
||||
"fetch_from": "item.stock_uom",
|
||||
"fetch_if_empty": 1,
|
||||
"fieldname": "uom",
|
||||
"fieldtype": "Link",
|
||||
"label": "UOM",
|
||||
"options": "UOM"
|
||||
},
|
||||
{
|
||||
"fieldname": "column_break_gcjw",
|
||||
"fieldtype": "Column Break"
|
||||
},
|
||||
{
|
||||
"fieldname": "item_name",
|
||||
"fieldtype": "Data",
|
||||
"label": "Item Name"
|
||||
},
|
||||
{
|
||||
"fieldname": "return_inspection_committee",
|
||||
"fieldtype": "Select",
|
||||
"label": "Return Inspection Committee",
|
||||
"options": "\nFor Repair\nFor Sale\nFor Disposal"
|
||||
}
|
||||
],
|
||||
"index_web_pages_for_search": 1,
|
||||
"istable": 1,
|
||||
"links": [],
|
||||
"modified": "2025-08-26 21:01:28.397119",
|
||||
"modified_by": "Administrator",
|
||||
"module": "Asset Lite",
|
||||
"name": "Item Transfer Table",
|
||||
"owner": "Administrator",
|
||||
"permissions": [],
|
||||
"sort_field": "modified",
|
||||
"sort_order": "DESC",
|
||||
"states": []
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2025, seyfert and contributors
|
||||
# For license information, please see license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.model.document import Document
|
||||
|
||||
|
||||
class ItemTransferTable(Document):
|
||||
pass
|
||||
@ -0,0 +1,8 @@
|
||||
// Copyright (c) 2025, seyfert and contributors
|
||||
// For license information, please see license.txt
|
||||
|
||||
// frappe.ui.form.on("Material Transfer", {
|
||||
// refresh(frm) {
|
||||
|
||||
// },
|
||||
// });
|
||||
@ -0,0 +1,128 @@
|
||||
{
|
||||
"actions": [],
|
||||
"allow_rename": 1,
|
||||
"autoname": "format:Material-Transfer-{####}",
|
||||
"creation": "2025-08-26 21:02:44.817236",
|
||||
"doctype": "DocType",
|
||||
"engine": "InnoDB",
|
||||
"field_order": [
|
||||
"hospital",
|
||||
"purpose",
|
||||
"source_warehouse",
|
||||
"asset",
|
||||
"column_break_irlz",
|
||||
"date",
|
||||
"reason_for_return",
|
||||
"transfer_type",
|
||||
"target_warehouse",
|
||||
"item",
|
||||
"section_break_bunw",
|
||||
"item_table",
|
||||
"asset_transfer"
|
||||
],
|
||||
"fields": [
|
||||
{
|
||||
"fieldname": "hospital",
|
||||
"fieldtype": "Link",
|
||||
"label": "Hospital",
|
||||
"options": "Company"
|
||||
},
|
||||
{
|
||||
"fieldname": "purpose",
|
||||
"fieldtype": "Select",
|
||||
"label": "Purpose",
|
||||
"options": "Transfer"
|
||||
},
|
||||
{
|
||||
"fieldname": "source_warehouse",
|
||||
"fieldtype": "Link",
|
||||
"label": "Source Warehouse",
|
||||
"options": "Warehouse"
|
||||
},
|
||||
{
|
||||
"depends_on": "eval:doc.transfer_type=='Asset'",
|
||||
"fieldname": "asset",
|
||||
"fieldtype": "Link",
|
||||
"label": "Asset",
|
||||
"options": "Asset"
|
||||
},
|
||||
{
|
||||
"fieldname": "column_break_irlz",
|
||||
"fieldtype": "Column Break"
|
||||
},
|
||||
{
|
||||
"default": "Today",
|
||||
"fieldname": "date",
|
||||
"fieldtype": "Date",
|
||||
"label": "Date"
|
||||
},
|
||||
{
|
||||
"fieldname": "reason_for_return",
|
||||
"fieldtype": "Select",
|
||||
"label": "Reason for Return",
|
||||
"options": "\nPurpose Completed\nSurplus\nUnusable\nDamaged"
|
||||
},
|
||||
{
|
||||
"fieldname": "transfer_type",
|
||||
"fieldtype": "Select",
|
||||
"label": "Transfer Type",
|
||||
"options": "\nAsset\nItem"
|
||||
},
|
||||
{
|
||||
"fieldname": "target_warehouse",
|
||||
"fieldtype": "Link",
|
||||
"label": "Target Warehouse",
|
||||
"options": "Warehouse"
|
||||
},
|
||||
{
|
||||
"depends_on": "eval:doc.transfer_type=='Item'",
|
||||
"fieldname": "item",
|
||||
"fieldtype": "Link",
|
||||
"label": "Item",
|
||||
"options": "Item"
|
||||
},
|
||||
{
|
||||
"fieldname": "section_break_bunw",
|
||||
"fieldtype": "Section Break"
|
||||
},
|
||||
{
|
||||
"depends_on": "eval:doc.transfer_type=='Item'",
|
||||
"fieldname": "item_table",
|
||||
"fieldtype": "Table",
|
||||
"label": "Item Table",
|
||||
"options": "Item Transfer Table"
|
||||
},
|
||||
{
|
||||
"depends_on": "eval:doc.transfer_type=='Asset'",
|
||||
"fieldname": "asset_transfer",
|
||||
"fieldtype": "Table",
|
||||
"label": "Asset Transfer",
|
||||
"options": "Asset Item Transfer"
|
||||
}
|
||||
],
|
||||
"index_web_pages_for_search": 1,
|
||||
"links": [],
|
||||
"modified": "2025-08-26 21:02:44.817236",
|
||||
"modified_by": "Administrator",
|
||||
"module": "Asset Lite",
|
||||
"name": "Material Transfer",
|
||||
"naming_rule": "Expression",
|
||||
"owner": "Administrator",
|
||||
"permissions": [
|
||||
{
|
||||
"create": 1,
|
||||
"delete": 1,
|
||||
"email": 1,
|
||||
"export": 1,
|
||||
"print": 1,
|
||||
"read": 1,
|
||||
"report": 1,
|
||||
"role": "System Manager",
|
||||
"share": 1,
|
||||
"write": 1
|
||||
}
|
||||
],
|
||||
"sort_field": "modified",
|
||||
"sort_order": "DESC",
|
||||
"states": []
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2025, seyfert and contributors
|
||||
# For license information, please see license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.model.document import Document
|
||||
|
||||
|
||||
class MaterialTransfer(Document):
|
||||
pass
|
||||
@ -0,0 +1,9 @@
|
||||
# Copyright (c) 2025, seyfert and Contributors
|
||||
# See license.txt
|
||||
|
||||
# import frappe
|
||||
from frappe.tests.utils import FrappeTestCase
|
||||
|
||||
|
||||
class TestMaterialTransfer(FrappeTestCase):
|
||||
pass
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user