// Include common libraries
/*
   AWS  Technologies vocabulary
*/

!const LIBRARY_VERSION 2.0

// Systems
!const AWS "AWS"
!const AWS.Description "Amazon Web Services"
!const AWS.Chime "Amazon Chime"
!const AWS.Chime.Description "Communications service that lets you meet, chat, and place business calls inside and outside your organization, all using a single application."
!const AWS.IAM "AWS IAM"
!const AWS.IAM.Description "Identity and Access Management"
!const AWS.STS "AWS STS"
!const AWS.STS.Description "Security Token Service"
!const AWS.SES "AWS SES"
!const AWS.SES.Description "Simple Email Service"
!const AWS.AppConfig "AWS AppConfig"
!const AWS.AppConfig.Description "Simplifies the administration of applications at scale by deploying configuration changes from a central location."
!const AWS.SNS "AWS Simple Notification Service"
!const AWS.SNS.Description "Provides message delivery from publishers to subscribers, also used for push notifications & SMS."
!const AWS.EventBridgeScheduler "AWS EventBridge Scheduler"
!const AWS.EventBridgeScheduler.Description "Scheduler for events."

// AWS Technologies
!const AWS_SQS "AWS Simple Queue Service"
!const AWS_REDIS "AWS ElastiCache for Redis"
!const AWS_SM "AWS SecretsManager"
!const AWS_LAMBDA "AWS Lambda"
!const AWS_RDS "AWS RDS"
!const AWS_DYNAMODB "AWS DynamoDB"
!const AWS_S3 "AWS S3"
!const AWS_SF "AWS StepFunction"
!const AWS_SF_NODE "AWS StepFunction Node"
!const AWS_SNS "AWS Simple Notificaction Service"
!const AWS_GLUE "AWS Glue"
!const AWS_API_GATEWAY "AWS API Gateway"

/*
    Common vocabulary constants
*/
!const RDCS "RocheDiabetes Care Solutions"
!const PROFSOL "Professional Solutions"
!const PLATFORM "Platform"
!const PERSONAL "Personal Solutions"
!const INFRASTRUCTURE "Infrastructure"
!const DEVICES "Devices"

/*
    Technologies vocabulary
*/
// Common technologies
!const TLS "TLS"
!const JDBC "JDBC"
!const JSP "JSP"
!const NODE "NodeJS"
!const SPRING_MVC "Spring MVC"
!const SPRING_BOOT "Spring Boot"
!const MSSQL_EE "SQL Server Enterprise Edition"
!const POSTGRESQL "PostgreSQL"
!const COUCHBASE "Couchbase"
!const COUCHBASE_LITE "Couchbase Lite"
!const DOTNET ".NET"
!const MFC "MFC"
!const SWIFT "Swift"
!const QT "Qt"
!const CPP "C++"
!const PYTHON "Python"

// Formats
!const ACSPIX "ACSPIX"
!const JSON "JSON"
!const EIF "EIF"
!const ROCHE_JSON "RocheJSON"
!const HTML "HTML"
!const PDF "PDF"
!const CSV "CSV"

// Communication channels
!const HTTPS "HTTPS"
!const JSON_HTTPS "JSON/HTTPS"
!const ACSPIX_HTTPS "ACSPIX/HTTPS"
!const FHIR_HTTPS "FHIR/HTTPS"
!const ROCHE_JSON_HTTPS "RocheJSON/HTTPS"
!const CDF_HTTPS "CDF/HTTPS"
!const EIF_HTTPS "EIF/HTTPS"
!const BINARY_HTTPS "BINARY/HTTPS"
!const WS "WebSocket"
!const PDF_HTTPS "PDF/HTTPS"

// Languages
!const JS "JavaScript"
!const TS "TypeScript"
!const REACT "React"
!const JAVA "Java"
!const MONO "Mono"
!const SCALA "Scala"

/*
    Persons constants
*/
!const ADMIN "Admin"
!const ADMIN.Description "Roche administrator, that manages onboardings and centers; is always considered an 'internal' user"
!const HCP "HCP"
!const HCP.Description "The health care professional is the medical practitioner treating the patient; is always considered an 'external' user"
!const HCP.Master "HCP Master"
!const HCP.Master.Description "The healthcare professional (Master - Owner of Healthcare Center); is always considered an 'external' user"
!const PWD "PwD"
!const PWD.Description "Patient with diabetes is the end user of the solution / system; is always considered an 'external' user"
!const DSS "DSS"
!const DSS.Description "Digital support service user is a special Roche internal user that has access to production environment and can perform various maintenance and corrective tasks"
!const DEVOPS "DevOps"
!const DEVOPS.Description "The DevOps user is an internal Roche user responsible for the operation and maintenance of the infrastructure"
!const ComplaintInvestigator "Complaint Investigator"
!const ComplaintInvestigator.Description "Internal Roche support team member responsible for investigating customer complaints"

/*
    Infrastructure systems constants
*/
!const GitLab.OnPremise "GitLab On-Premise"
!const GitLab.OnPremise.Description "GitLab on-premise instance"
!const StaticAppsS3 "Static Apps (AWS.S3 Bucket)"
!const StaticAppsS3.Description "Container for static apps and web apps resources"
!const FeatureFlagService.OnPremise "Feature Flag Service On-Premise"
!const FeatureFlagService.OnPremise.Description "GO Feature Flag Service on-premise instance for serving FFs"
!const LogManagement "LogManagement"
!const LogManagement.Description "The RDC Observability tool used by all components"

/*
    Personal ART vocabulary system constants
*/
!const Personal.mySugr "Personal.mySugr"
!const Personal.mySugr.Description "Application for managing and tracking diabetes in patients"
!const Personal.mySugr.Backend "Personal.mySugr.Backend"
!const Personal.mySugr.Backend.Description "mySugr backend application to support mobile application"
!const Personal.Glucolytics "Personal.Predict"
!const Personal.Glucolytics.Description "(Accu-Chek SmartGuide Predict) Application that provides algorithmic predictions about future glucose levels based on collected medical data of patient"
!const Personal.Glucolytics.Backend "Personal.Predict.Backend"
!const Personal.Glucolytics.Backend.Description "Backend representing a collection of services for generating predictions of glycemic events for the user by loading a previously generated model or by implementing a mathematical calculation."
!const Personal.SmartGuide "Personal.SmartGuide"
!const Personal.SmartGuide.Description "(aka Confidence) Mobile application for connecting with CGM device for data readout and tracking"

/*
    Plaform ART vocabulary system constants
*/
!const Platform.ApiManager "Platform.ApiManager"
!const Platform.ApiManager.Description "The Roche ecosystem API Gateway used to NAT all the traffic to / from each solution and service"
!const Platform.ApiGateway "Platform.ApiGateway"
!const Platform.ApiGateway.Description "The Roche ecosystem API Gateway used to NAT all the traffic to / from each solution and service"
!const Platform.CIAMCM "Platform.CIAMCM"
!const Platform.CIAMCM.Description "Customer Identity and Access Management and Consent Management is the central storage for identity and consents of each user"
!const Platform.CIAMCM.Gigya "Platform.CIAMCM.Gigya"
!const Platform.CIAMCM.Gigya.Description "CIAMCM's Gigya instance for user identity management"
!const Platform.DiagnosticsAndMedications "Platform.DiagnosticsAndMedications (FHIRStack)"
!const Platform.DiagnosticsAndMedications.Description "Allows storage and retrieval of diagnostics and medications data of the patients."
!const Platform.DataIntegrations "Platform.DataIngetrations"
!const Platform.DataIntegrations.Description "Data integrations layer"
!const Platform.PHDIAM "Platform.PHDIAM"
!const Platform.PHDIAM.Description "Certficate authorization and access management."
!const Platform.RDAC "Platform.RocheDiabetes AccountCenter (aka Accu-Chek Account Center)"
!const Platform.RDAC.Description "(aka Accu-Chek Account Center) App for Patient registrations in RDC"
!const Platform.ApplicationSettings "Platform.ApplicationSettings"
!const Platform.ApplicationSettings.Description "Store, retrieve and share settings for mobile apps"
!const Platform.BLE "Platform.ConfidenceBLE"
!const Platform.BLE.Description "Retrieve optimized set of parameters for BLE connection"
!const Platform.ComplaintInvestigation "Platform.ComplaintInvestigation"
!const Platform.ComplaintInvestigation.Description "Search and aggregate data from multiple domains and return it to caller"
!const Platform.PushNotification "Platform.PushNotification"
!const Platform.PushNotification.Description "Send push notifications to registered devices"
!const Platform.RADAR "Platform.RADAR"
!const Platform.RADAR.Description "Roche Analytics for Reporting and product usage KPIs"
!const Platform.BDA "Platform.BDA"
!const Platform.BDA.Description "Big Data and Analytics"

/*
    Professional solution (Professional ART) vocabulary system constants
*/
// RDCP
!const RDCP "RocheDiabetes Care Platform (RDCP) | Accu-Chek Care (ACC)"

!const RDCP.HCP.Portal "RDCP.HCPPortal"
!const RDCP.HCP.Portal.Description "Allows Healthcare Professional accessing their patients and their medical data."
!const RDCP.HCP.SelfReg "RDCP.HCPSelf-Registration"
!const RDCP.HCP.SelfReg.Description "Allows owners of HCC's to register their Healthcare Center to start managing their healthcare center and patients in RDCP."
//!const RDCP.BackofficePortal "RDCP.BackofficePortal"
//!const RDCP.BackofficePortal.Description "Allows Roche Admins onboarding processes for new healthcare centers and management of existing ones."
!const RDCP.UniversalDTC "RDCP.UniversalDTC"
!const RDCP.UniversalDTC.Description "Allows readout and upload of medical data from blood glucose devices, insulin pumps and CGMs into RDCP."
!const RDCP.Patient.Portal "RDCP.PatientPortal"
!const RDCP.Patient.Portal.Description "(Available only for RDCP) Allows patients to visualize their medical data, personal information and access home delivery."

!const RDCP.Core "RDCP.Core"
!const RDCP.Core.Description "Collection of core Backend Services to support RDCP (including monolithic app)."
!const RDCP.Permissions "RDCP.Permissions"
!const RDCP.Permissions.Description "Allows validation of permissions, modules and access to specific resources within RDCP."
!const RDCP.Notifications "RDCP.Notifications"
!const RDCP.Notifications.Description "Allows management of Notifications."
!const RDCP.StripsManagement "RDCP.StripsManagement"
!const RDCP.StripsManagement.Description "Allows strips management (stock, delivery)."
!const RDCP.Patterns.And.Indicators "RDCP.PatternsAndIndicators"
!const RDCP.Patterns.And.Indicators.Description "Allows enrichment patient's status based on predefined set of patterns."
!const RDCP.UserManagement.And.Records "RDCP.UserManagementAndRecords"
!const RDCP.UserManagement.And.Records.Description "Allows centralized access and management of RDCP users."
!const RDCP.Diagnostics.And.Medications "RDCP.DiagnosticsAndMedications"
!const RDCP.Diagnostics.And.Medications.Description "Diagnostics and Medications."
// DEPREACTED for Koala release
//!const RDCP.UniversalDTC.Services "RDCP.UniversalDTC.Services"
//!const RDCP.UniversalDTC.Services.Description "Allows additional support of various functionalities of uDTC (whitelisting of devices and their versions that are supported by RDCP)."
!const RDCP.Organizations "RDCP.Organizations"
!const RDCP.Organizations.Description "Provides APIs for management of organizations"
!const RDCP.Analytics "RDCP.Analytics"
!const RDCP.Analytics.Description "Allow recollection of metrics for analytics"
!const RDCP.Devices "RDCP.Devices"
!const RDCP.Devices.Description "Management of devices."
!const RDCP.Reporting "RDCP.Reporting"
!const RDCP.Reporting.Description "Reporting services."
!const RDCP.ConfigurationManagement "RDCP.ConfigurationManagement"
!const RDCP.ConfigurationManagement.Description "Management of configurations"
// VisitModule (Part of RDCP)
!const VisitManagement.And.Communication "RDCP.VisitManagementAndCommunication"
!const VisitManagement.And.Communication.Description "Allows managements of patients visits to the HCP's, recording of notes and communication between PwD's and HCP's."

// (Legacy) SmartPixSoftware (DEPRECATED)
!const SPSW "SmartPixSoftware (SPSW)"

!const SPSW.Desktop "SPSW.DesktopClient"
!const SPSW.Desktop.Description "Legacy Desktop Application for HCP's Management of the patients"

// SmartPix2Cloud (DEPRECATED)
!const SP2C "SmartPix2Cloud (SP2C)"
!const SP2C.Description "Allows patient (and their data) migration from legacy SPSW solution and RDCP"

!const SP2C.Desktop "SP2C.Desktop"
!const SP2C.Desktop.Description "Desktop application that provides one-way data sync between SPSW and RDCP"
!const SP2C.Backend "SP2C.Backend"
!const SP2C.Backend.Description "Backend components of Smart Pix to Cloud"

// Devices
!const Devices.CGMPatch "CGM.Patch"
!const Devices.CGMPatch.Description "Roche CGM Sensor Patch (part of Accu-Chek SmartGuide CGM)"
!const Devices.MicroPump "MicroPump"
!const Devices.MicroPump.Description "Accu-Chek Solo Micro Insulin Pump"

!const Personal.glucoseInsights "mysugr G.I."
!const Personal.glucoseInsights.Description "Display and read-out of CGM sensor. Visualize and analyze diabetes data"

workspace "CGM 2.0 Algos" "Smart Meal manager and Insulin Start Algos overview" {

    // Make identifiers hierarchical (e.g. rdcp.systemA.componentB)
    !identifiers hierarchical
    // Make relationships to be propagated to higher levels from component views (and lower)
    !impliedRelationships true

    !docs src/docs

    model {
        properties {
            "structurizr.groupSeparator" "/"
        }

        // add AWS systems
        /*
            AWS Services
        */
        group "${AWS} - ${AWS.Description}" {
            awsChime = element "${AWS.Chime}" {
                tags "AWS, Amazon Web Services - Chime"
                description "${AWS.Chime.Description}"
            }
            awsIAM = element "${AWS.IAM}" {
                tags "AWS, Amazon Web Services - AWS Identity Access Management Role"
                description "${AWS.IAM.Description}"
            }
            awsSTS = element "${AWS.STS}" {
                tags "AWS, Amazon Web Services - AWS Identity Access Management Role"
                description "${AWS.STS.Description}"
            }
            awsSES = element "${AWS.SES}" {
                tags "AWS, Amazon Web Services - Simple Email Service"
                description "${AWS.SES.Description}"
            }
            awsAppConfig = element "${AWS.AppConfig}" {
                tags "AWS, Amazon Web Services - AppConfig"
                description "${AWS.AppConfig.Description}"
            }
            awsSNS = element "${AWS.SNS}" {
                tags "AWS, Amazon Web Services - Simple Notification Service"
                description "${AWS.SNS.Description}"
            }
            awsEventBridgeScheduler = element "${AWS.EventBridgeScheduler}" {
                tags "AWS, Amazon Web Services - EventBridge Scheduler"
                description "${AWS.EventBridgeScheduler.Description}
            }
        }
        // add persons, generic & 3rd party systems
        // internal actors
        group "${RDCS}" {
            dss = person "${DSS}" "${DSS.Description}" "RocheActor"
            devops = person "${DEVOPS}" "${DEVOPS.Description}" "RocheActor"
            admin = person "${ADMIN}" "${ADMIN.Description}" "RocheActor"
            complaintInvestigator = person "${ComplaintInvestigator}" "${ComplaintInvestigator.Description}" "RocheActor"
        }
        
        // external actors
        hcpMaster = person "${HCP.Master}" "${HCP.Master.Description}" "ExternalActor"
        hcp = person "${HCP}" "${HCP.Description}" "ExternalActor"
        pwd = person "${PWD}" "${PWD.Description}" "ExternalActor"
        emrSystem = softwareSystem "EMR Middleware" "Hospital middleware for connecting with Roche interoperability layer" {
            tags "External System"
        } 
        muleSoftControlPlaneSystem = softwareSystem "Mulesoft Control Plane" "Anypoint Control Plane" {
            tags "External System"
        } 
        gigya = softwareSystem "SAP CDC (ex-Gigya)" "SAP CDC instance for user identity management" {
            tags "External System"
        }
        morpheusApp = softwareSystem "Morpheus Application" "Retrieves data from Platform for displaying, correlating with internal data or further processing the data" {
            tags "Web Application, External System"
        }
        confluenceCloud = softwareSystem "Confluence Cloud" "Atlassian Confluence cloud instance" {
            tags "External System"
        }
        githubCloud = softwareSystem "GitHub" "GitHub cloud instance" {
            tags "External System"
        }
        partner = softwareSystem "Partner" "3rd party companies that have partnered with Roche to extend their offering and benefit from our expertise" {
            tags "External System"
        }

        // add systems
        group "${RDCS}" {
            // Platform level systems
            group "${PLATFORM}" {
                apiManager = softwareSystem "${Platform.ApiManager}" "${Platform.ApiManager.Description}"
                apiManagerConsoleWebApp = softwareSystem "API Manager.Console" "Some web application" {
                    tags "Web Application"
                }
                apiGateway = softwareSystem "${Platform.ApiGateway}" "${Platform.ApiGateway.Description}"
                ciamcm = softwareSystem "${Platform.CIAMCM}" "${Platform.CIAMCM.Description}"
                rdac = softwareSystem "${Platform.RDAC}" "${Platform.RDAC.Description}"
                fhirStack = softwareSystem "${Platform.DiagnosticsAndMedications}" "${Platform.DiagnosticsAndMedications.Description}"
                dataIntegration = softwareSystem "${Platform.DataIntegrations}" "${Platform.DataIntegrations.Description}"
                phdIam = softwareSystem "${Platform.PHDIAM}" "${Platform.PHDIAM.Description}"
                appSettings = softwareSystem "${Platform.ApplicationSettings}" "${Platform.ApplicationSettings.Description}"
                ble = softwareSystem "${Platform.BLE}" "${Platform.BLE.Description}"
                complaintInvestigation = softwareSystem "${Platform.ComplaintInvestigation}" "${Platform.ComplaintInvestigation.Description}"
                pushNotification = softwareSystem "${Platform.PushNotification}" "${Platform.PushNotification.Description}"
                radar = softwareSystem "${Platform.RADAR}" "${Platform.RADAR.Description}"
                bda = softwareSystem "${Platform.BDA}" "${Platform.BDA.Description}"
            }
        
            // Mobile systems (personal)
            group "${PERSONAL}" {
                // mySugr
                mySugrApp = softwareSystem "${Personal.mySugr}" {
                    properties {
                        "ART" "Personal"
                    }
                    tags "Mobile Application"
                    description "${Personal.mySugr.Description}"
                }
        
                // accu-chek smartguide predict app (aka smartlife, glucolytics)
                glucolyticsApp = softwareSystem "${Personal.Glucolytics}" {
                    properties {
                        "ART" "SmartLife"
                    }
                    tags "Mobile Application"
                    description "${Personal.Glucolytics.Description}"
                }
        
                // accu-check smartguide app
                smartguideApp = softwareSystem "${Personal.SmartGuide}" {
                    properties {
                        "ART" "Confidence"
                    }
                    tags "Mobile Application"
                    description "${Personal.SmartGuide.Description}"
                }
            }
        
            group "${PERSONAL}.Backend" {
                // mysugr
                mySugrBackend = softwareSystem "${Personal.mySugr.Backend}" {
                    properties {
                        "ART" "Personal"
                    }
                    tags ""
                    description "${Personal.mySugr.Backend.Description}"
                }
                // smartguide predict app
                glucolyticsBackend = softwareSystem "${Personal.Glucolytics.Backend}" {
                    properties {
                        "ART" "SmartLife"
                    }
                    tags ""
                    description "${Personal.Glucolytics.Backend.Description}"
                }
            }
        
            // Professional systems
            // RocheDiabetesCare(Accu-Chek Care)-related
            group "${PROFSOL}" {
                group "${RDCP}" {
                    rdcpAnalytics = softwareSystem "${RDCP.Analytics}" "${RDCP.Analytics.Description}" "ProfessionalSolutions"
                    // as part of Koala release no longer considered as a separate system, but rather part of Core / HCP Backend
        //            backofficePortal = softwareSystem "${RDCP.BackofficePortal}" "${RDCP.BackofficePortal.Description}" "ProfessionalSolutions"
                    rdcpConfigurationManagement = softwareSystem "${RDCP.ConfigurationManagement}" "${RDCP.ConfigurationManagement.Description}" "ProfessionalSolutions"
                    rdcpDevices = softwareSystem "${RDCP.Devices}" "${RDCP.Devices.Description}" "ProfessionalSolutions"
                    rdcpDiagnosticsAndMedications = softwareSystem "${RDCP.Diagnostics.And.Medications}" "${RDCP.Diagnostics.And.Medications.Description}" "ProfessionalSolutions"
                    rdcpHcpPortal = softwareSystem "${RDCP.HCP.Portal}" "${RDCP.HCP.Portal.Description}" "ProfessionalSolutions"
                    rdcpHcpSelfRegistration = softwareSystem "${RDCP.HCP.SelfReg}" "${RDCP.HCP.SelfReg.Description}" "ProfessionalSolutions"
                    rdcpCore = softwareSystem "${RDCP.Core}" "${RDCP.Core.Description}" "ProfessionalSolutions"
                    rdcpNotifications = softwareSystem "${RDCP.Notifications}" "${RDCP.Notifications.Description}" "ProfessionalSolutions"
                    rdcpOrganizations = softwareSystem "${RDCP.Organizations}" "${RDCP.Organizations.Description}" "ProfessionalSolutions"
        //            patientPortal = softwareSystem "${RDCP.Patient.Portal}" "${RDCP.Patient.Portal.Description}" "ProfessionalSolutions"
                    rdcpPatternsAndIndicators = softwareSystem "${RDCP.Patterns.And.Indicators}" "${RDCP.Patterns.And.Indicators.Description}" "ProfessionalSolutions"
                    rdcpPermissions = softwareSystem "${RDCP.Permissions}" "${RDCP.Permissions.Description}" "ProfessionalSolutions"
                    rdcpReporting = softwareSystem "${RDCP.Reporting}" "${RDCP.Reporting.Description}" "ProfessionalSolutions"
                    rdcpStripsManagement = softwareSystem "${RDCP.StripsManagement}" "${RDCP.StripsManagement.Description}" "ProfessionalSolutions"
                    rdcpUdtc = softwareSystem "${RDCP.UniversalDTC}" "${RDCP.UniversalDTC.Description}" "ProfessionalSolutions"
        //            rdcpUdtcServices = softwareSystem "${RDCP.UniversalDTC.Services}" "${RDCP.UniversalDTC.Services.Description}" "ProfessionalSolutions"
                    rdcpUserManagementAndRecords = softwareSystem "${RDCP.UserManagement.And.Records}" "${RDCP.UserManagement.And.Records.Description}" "ProfessionalSolutions"
                    rdcpVisitManagementAndCommunication = softwareSystem "${VisitManagement.And.Communication}" "${VisitManagement.And.Communication.Description}" "ProfessionalSolutions"
                }
                // SmartPix2Cloud-related
                // As part of Koala release SP2C is decommissioned
        //        group "${SP2C}" {
        //            sp2cBackend = softwareSystem "${SP2C.Backend}" "${SP2C.Backend.Description}" "ProfessionalSolutions"
        //            sp2cDesktop = softwareSystem "${SP2C.Desktop}" "${SP2C.Desktop.Description}" "ProfessionalSolutions"
        //        }
                // SmartPix Software-related
        //        group "${SPSW}" {
        //            spswDesktop = softwareSystem "${SPSW.Desktop}" "${SPSW.Desktop.Description}" "ProfessionalSolutions"
        //        }
                // Visit Management & Communication-related
                // As part of Koala moved into Accu-Chek Care
        //        group "${VisitManagement.And.Communication}" {
        //
        //        }
            }
        
            // Infra Systems
            group "${INFRASTRUCTURE}" {
                gitlabOnPremise = softwareSystem "${GitLab.OnPremise}" "${GitLab.OnPremise.Description}" {
                    tags "External System"
                }
                staticApps = softwareSystem "${StaticAppsS3}" "${StaticAppsS3.Description}" {
                    tags "AWS, Amazon Web Services - Simple Storage Service Bucket"
                }
        
                featureFlagServiceOnPremise = softwareSystem "${FeatureFlagService.OnPremise}" "${FeatureFlagService.OnPremise.Description}" {
                    tags "External System"
                }  
                logs = softwareSystem "${LogManagement}" "${LogManagement.Description}" {
                    tags "External System"
                }
            }
        
            group "${DEVICES}" {
                cgm = element "${Devices.CGMPatch}" "${Devices.CGMPatch.Description}" {
                    tags "CGM Patch"
                }
                micropump = element "${Devices.MicroPump}" "${Devices.MicroPump.Description}" {
                    tags "Pump"
                }
            }
        }

        /*
            Here we describe a few typical 'external' actors for the solution / system.
            These are persons and they can be useful for the solution or not, depending on the purpose (service used by other solutions / apps / backends)
            Other types of users can be defined, these are the typical ones only.

            Majority of actors are already defined in library/common/persons.dsl, reuse them through reference (!ref).

            Tag elements with "External System" to explicitly state them as external.
        */
        !element pwd {
            tags "External System" "SMMscope"
        }

        cs-subject = person "Clinical study Subject" {
            description "A person participating in clinical study. No personal data or details are known about this subject"
            tags "External System" "SMMscope"
        }


        /*
            Devices
        */
        group "Devices" {
            cgm1 = element "CGM Patch" "Roche CGM Path" {
                tags "CGM Patch"
                properties {
                    "ART" "CGM ART"
                }
                perspectives {
                    Security "CGM Patch is worn by the PwD"
                }
            }
        }

        /*
            Always use constants for Groups/Systems definitions & description, to avoid redundancy and copy-paste.
            You can find list of all terminologies in library/common/terminology.dsl
        */
        group "${RDCS}" {
            /*
                Here we describe a few typical 'internal' actors for the solution / system.
                These are persons and they can be useful for the solution or not, depending on the purpose (service used by other solutions / apps / backends)
                Other types of users can be defined, these are the typical ones only
            */
            !element dss {
                tags "SMMscope"
            }
            !element devops {
                tags "SMMscope"
            }

            !element complaintInvestigator {
                tags "SMMscope"
            }

            /*
                Here are described some generic software systems in the Roche ecosystem
                These are not exhaustive, just a few general ones used by all the solutions
                The solution specifics and it's dependencies have to be added below
                The systems below as well as the solution specific ones must follow the naming conventions of the Roche Architectural Standard as defined
                here: https://confluence.rochedc.accentureanalytics.com/pages/viewpage.action?pageId=148046784
            */
            !element logs {
                tags "SMMscope"
            }

            complaint_tool = softwareSystem "RDC Complaint Handling Tool" "The Roche Complaint handling tool set used by various levels of support, like Morpheus or SalesForce" {
                tags "External System" "SMMscope"
            }

            group "${PLATFORM}" {
                !element apiManager {
                    tags "External System" "SMMscope"
                    properties {
                        security yes
                    }
                }
                !element ciamcm {
                    tags "External System" "SMMscope"
                    properties {
                        security yes
                    }
                }
                !element rdac {
                    tags "External System" "SMMscope"
                    properties {
                        security yes
                    }
                }

                !element fhirStack {
                    tags "External System" "SMMscope"

                }

                !element pushNotification {
                    tags "External System" "SMMscope"

                }

                !element complaintInvestigation {
                    tags "External System" "SMMscope"

                }

                !element bda {
                    tags "External System" "SMMscope"

                }

                !element radar {
                    tags "External System" "SMMscope"

                }

                countly = softwareSystem "RDC Count.ly" "The Roche Count.ly instance for collecting tracking points from mobile application and other cutomer facing interfaces" {
                    tags "External System" "SMMscope"
                }
            }

            group "${RDCP}" {
                !element rdcpHcpPortal {
                    tags "External System" ""

                }
                !element rdcpReporting {
                    tags "External System" "SMMscope"

                }
            }

            group "${PERSONAL}" {
                !element glucolyticsBackend {
                    tags "" "SMMscope"

                }

                !element mySugrBackend {
                    tags "External System" "SMMscope"

                }

                cgm20_be = softwaresystem "Algo acceleration Backend" "Adjacent backend for Predict, consisting of services ncessary for SMM and IS algos. Works on Clincial Study data only!" {
                    tags "SMMscope"
                    dataproc = container "Data processing services" {
                        description "Collection of services for subject and health data processing and storage"
                        technology nodeJS
                        tags nodejs
                    }
                    smm_wrapper = container "SMM algo services" {
                        description "The algo services concuring to SSM feature"
                        technology python
                        tags python
                    }
                }
            }
        }

        /*
            A subset of the applications are the mobile apps
            These are outside of the Roche ecosystem when in use but are build by Roche
        */
        mySugrApp1 = softwareSystem "mySugr" {
            description "The Glucose Insights represents a container (module) inside the host app, mySugr"
            tags "SMMscope" "ios_android" "Mobile Application"

            glucoseInsights = container "${Personal.glucoseInsights}" "${Personal.glucoseInsights.Description}" {
                technology "Kotlin & Swift"

                tags kotlin_swift
            }
            hostApp = container "mySugr LogBook" "The foundation of the mySugr apps (modules), serves as the logging & data display for the rest of the hosted modules." {
                technology "Kotlin & Swift"

                tags kotlin_swift
            }
        }

        cgm20_fe = softwareSystem "AlgoAcc - CSapps" {
            description "The Glucose Insights represents a container (module) inside the host app, mySugr"
            tags "SMMscope" "ios_android" "Mobile Application" "External System"
        }

        # relationships between external actors and systems
        pwd -> mySugrApp1 "Uses" "View"
        hcp -> rdcpHcpPortal "Accesses" "View"
        pwd -> cgm1 "Wears" "Body Patch"

        cs-subject -> cgm1 "Wears" "Body Patch"
        cs-subject -> cgm20_fe "Uses" "View"

        # relationships between apps and devices
        mySugrApp1 -> cgm1 "Pairs with" "Bluetooth"

        # relationships between apps and cloud / backend software systems
        mySugrApp1 -> rdac "Loads" "web view"
        mySugrApp1 -> ciamcm "Get user data and consents from" "JSON/HTTP"
        mySugrApp1 -> apiManager "Send/Receive data" "JSON/HTTP"
        rdcpHcpPortal -> apiManager "Get data using APIs from" "JSON/HTTP"

        ## cs-app interaction
        cgm20_fe -> apiManager "Send/Receive data" "JSON/HTTP"

        # relationships between software systems
        ## security principles and user auth
        apiManager -> ciamcm "Authenticate & Autorize user using" "JSON/HTTP"

        apiManager -> mySugrBackend "Forward relevant authenticated calls to" "JSON/HTTP"

        apiManager -> cgm20_be "Forward relevant authenticated calls to" "JSON/HTTP"

        ## from the BE to other sw systems
        mySugrBackend -> fhirStack "Send data to" "Kinesis Data Stream" {
            tags "kinesis"
        }
        mySugrBackend -> glucolyticsBackend "Create profile in / Get Predictions & report from" "JSON/HTTP"
        fhirStack -> glucolyticsBackend "Sync new data to" "JSON/SNS" {
            tags "sns"
        }
        mySugrBackend -> pushNotification "Register user on / Send notification with" "JSON/HTTP"
        glucolyticsBackend -> pushNotification "Send notification with" "JSON/HTTP"
        pushNotification -> mySugrApp1 "Send notification to" "Push" {
            tags "push"
        }

        ## CGM2.0 system to others
        cgm20_be -> glucolyticsBackend "Get data / Send Notification / Store output" "JSON/SNS"

        ## from external systems to analytics layer
        fhirStack -> bda "Send new data to" "Kinesis Firehose"{
            tags "kinesis" "analytics"
        }
        fhirStack -> radar "Send new data to" "Kinesis Firehose"{
            tags "kinesis" "analytics"
        }
        glucolyticsBackend -> bda "Send prediction logs to" "Kinesis Firehose"{
            tags "kinesis" "analytics"
        }
        radar -> countly "Get tracking points from"

        ## complaint investigations
        complaintInvestigator -> complaint_tool "Uses" "View data" {
            tags ""
        }
        complaintInvestigation -> complaint_tool "Send application and device data to" "JSON/SNS" {
            tags "sns"
        }
        complaint_tool -> complaintInvestigation "Read user application, device and diagnostics data from" "JSON/HTTP" {
            tags ""
        }
        complaintInvestigation -> fhirStack "Get data for complaint handling from" "JSON/HTTP"

        ## reports generation
        mySugrBackend -> rdcpReporting "Request report from" "JSON/HTTP"
        glucolyticsBackend -> rdcpReporting "Request report from" "JSON/HTTP"
        mySugrApp1 -> rdcpReporting "Download report from" "tcp" {
            tags "tcp"
        }

        # relationships between internal actors and software systems
        devops -> logs
        dss -> logs

        # relations between containers
        pwd -> mySugrApp1.glucoseInsights

        mySugrApp1.glucoseInsights -> mySugrApp1.hostApp "Read / write data using"
        mySugrApp1.glucoseInsights -> cgm1 "Reads CGM value from" "Bluetooth"

        cgm20_fe -> cgm20_be.dataproc "Sends data to / Gets predictions from" "HTTP/JSON"

        mySugrApp1.hostApp -> mySugrBackend "Read / Write data from / to" "JSON/HTTP"
        mySugrApp1.glucoseInsights -> mySugrBackend "Read / Write data from / to" "JSON/HTTP"

        cgm20_be.dataproc -> cgm20_be.smm_wrapper "Sends data to / gets prediction using" "HTTP/JSON"
        cgm20_be.dataproc -> glucolyticsBackend "Sends to / gets data from" "HTTP/JSON"
        glucolyticsBackend -> cgm20_be.smm_wrapper "Get prediction from" "HTTP/JSON"
}

    views {
        systemLandscape "GILandscape" "mySugr Glucose Insights Landscape" {
            /* Not working with library includes */
            //include *
            include "element.tag==SMMscope" cgm1
        }

        container cgm20_be "SMM-Integration" "Overview of the SMM (and IS) current state" {
            include * cs-subject pwd mySugrApp1.hostApp mySugrApp1.glucoseInsights mySugrBackend
            exclude "glucolyticsBackend -> cgm20_be.smm_wrapper"
        }

        dynamic cgm20_be.smm_wrapper "SMM-Integration-work" {
            title "Target architecture for SMM"
            description "The scope and work and target architecture to integrate the output of Meal Manager into mySugr app"
        
            pwd -> cgm1 "Wears" "Body Patch"
            pwd -> mySugrApp1.glucoseInsights "Uses"
        
            mySugrApp1.glucoseInsights -> mySugrApp1.hostApp "Read / write data using"
            mySugrApp1.glucoseInsights -> cgm1 "Reads CGM value from" "Bluetooth"
        
            mySugrApp1.hostApp -> mySugrBackend "Read / Write data from / to" "JSON/HTTP"
            mySugrApp1.glucoseInsights -> mySugrBackend "Read / Write data from / to" "JSON/HTTP"
        
            mySugrBackend -> fhirStack "Send data to" "Kinesis Data Stream"
            mySugrBackend -> glucolyticsBackend "Create profile in / Get Predictions & report from" "JSON/HTTP"
            fhirStack -> glucolyticsBackend "Sync new data to" "JSON/SNS"
            mySugrBackend -> pushNotification "Register user on / Send notification with" "JSON/HTTP"
            glucolyticsBackend -> pushNotification "Send notification with" "JSON/HTTP"
        
        }

        # styling

        // Themes: https://docs.structurizr.com/ui/diagrams/themes
        // (!) Update from localhost to url on-premise when deploying to Tools (PROD)
        // https://structurizr.tools.rdcplatform.com/static/roche-theme.json
        themes roche-theme.json https://static.structurizr.com/themes/amazon-web-services-2023.01.31/theme.json
        // https://static.structurizr.com/themes/amazon-web-services-2023.01.31/theme.json
        // https://static.structurizr.com/themes/amazon-web-services-2020.04.30/theme.json
        // AWS vizualizer: https://structurizr.com/help/theme?url=https://static.structurizr.com/themes/amazon-web-services-2023.01.31/theme.json
        // AWS vizualizer: https://structurizr.com/help/theme?url=https://static.structurizr.com/themes/amazon-web-services-2020.04.30/theme.json
        // another version: https://static.structurizr.com/themes/amazon-web-services-2023.01.31/theme.json
        branding {
            logo roche-logo.png
        }

        styles {
            element "Group" {
                background #d3d3d3
                color #4C4C4C
                stroke #4C4C4C
                strokeWidth 10
                icon library/common/roche-logo.png
            }
            element "CGM Patch" {
                shape Circle
                color #0038a8
            }
            element "ios_android" {
                icon resources/imgs/ios_android.jpg
            }
            element "android" {
                icon resources/imgs/android.png
            }
            element "sqs" {
                shape Cylinder
                icon resources/imgs/aws_sqs.png
            }
            element "sns" {
                shape Pipe
                icon resources/imgs/aws_sns.png
            }
            element "kinesis_stream" {
                shape Pipe
                icon resources/imgs/aws_kinesis_stream.png
            }
            element "lambda" {
                shape RoundedBox
                icon resources/imgs/aws_lambda.png
            }
            element "python" {
                icon resources/imgs/python.png
            }
            element "nodejs" {
                icon resources/imgs/nodejs.png
            }
            element "java" {
                icon resources/imgs/java.png
            }
            /* Mainly for containers - but not limited to */
            element "kotlin_swift" {
                shape Component
                icon resources/imgs/kotlin_swift.png
            }
            element "realm" {
                shape Cylinder
                icon resources/imgs/and_realm.jpg
                background white
                color green
                stroke green
            }
            element "room" {
                shape Cylinder
                icon resources/imgs/room_db.png
                background white
                color green
                stroke green
            }
            element "mobile_sec_pref" {
                shape Cylinder
                icon resources/imgs/secure_preferences.png
                background white
                color red
                stroke green
            }
            element "mobile_pref" {
                shape Cylinder
                icon resources/imgs/preferences.png
                background white
                color grey
                stroke green
            }
            element "mobile_file" {
                shape Folder
                icon resources/imgs/file_storage.png
                background white
                color green
                stroke green
            }
            /* Relationship styling */
            relationship "Relationship" {
                style solid
                routing Orthogonal
                position 80
            }
            relationship "sns" {
                color blue
            }
            relationship "sqs" {
                color red
            }
            relationship "tcp" {
                color green
            }
            relationship "kinesis" {
                color #8a2be2
            }
            relationship "analytics" {
                style dashed
            }
            relationship "push" {
                style dashed
                color green
            }
        }
    }
}