How abdalla-ham/datadito works
Main Components
• Frontend / Client Applications:
– Mobile: DataDito-iOS (an iOS application with Swift code for user interface, models, and view models).
– Web: web-application and Web.NetDataDito serve as the web-based clients (using Java-based controllers and view HTML pages).
– Desktop: DesktopApp (Java) and DotNetDesktopApp (.NET), offering a desktop client experience.
• Backend / Service Layer:
– Multiple service modules (for instance, ABMF, CGF, CHF, aom, TGF, NF) that likely handle different aspects such as authentication, transactions, and business logic.
– Each module typically contains classes like ConfigLoader, DataSourceConfig, controller classes, and business logic operations (e.g., OracleOperations, OracleCRUD in multiple modules).
• Integration / Middleware:
– Kafka module: Contains classes to produce and consume messages (producers, consumers, serializers, deserializers, topic managers) that facilitate message-driven communication between services.
– Hazelcast: Likely used as an in-memory data grid or caching service; its modules include manager classes and configurations.
• Data Stores:
– The project references Oracle operations, VoltDB (modules for testing DB operations) and possibly other external databases. Configuration files and SQL scripts (e.g., PROCEDURES.sql, TABLE-CREATING.sql) indicate planned persistent stores.
• Infrastructure & Deployment:
– Dockerfiles in several modules (for ABMF, CGF, aom, web-application, etc.) indicate containerized deployment.
– Maven build scripts (pom.xml) are used across projects.
– There are configuration files (application.properties, kafka-config.properties, log4j2.xml) which allude to centralized configuration management.
• Test & Utility Components:
– tracerBullet contains test cases in C# for UI testing and/or automation.
– Other directories (such as NF and TrendyolLogInTest) suggest additional test or integration setups.
Relationships and Interactions
• How backend services interact with the messaging layer (Kafka) to decouple communication.
• If extra integration components (like email via JakartaMail or external API calls) are present, include directional flows for those interactions.
Architectural Patterns and Design Principles
• Microservices / Modularization: Each backend module (ABMF, CGF, CHF, aom, etc.) can be shown as a separate service component that encapsulates specific business functionality.
• Layered Architecture: At one level you have presentation (mobile, web, desktop) and at another, the business logic layer (the service modules), and then the data layer (databases, caching).
• Event-Driven / Messaging: Emphasize the Kafka messaging service, with clear roles for producers and consumers, which decouples some services.
• Containerization: Note the Dockerfiles and Maven wrapper usage to highlight deployment practices.
• Use of Configuration and Externalized Properties: Several projects include properties files indicating the reliance on external configuration.
Relevant Technologies and Frameworks
• Java (with Maven for dependency management) is a core component of many backend services.
• .NET is used (in DotNetDesktopApp) for desktop client development.
• Swift is used for the iOS application.
• Kafka is integrated for messaging (with custom serializers/deserializers).
• Hazelcast is used for caching or distributed messaging.
• Docker is used for deployment containerization.
• Logging is handled via log4j2, and there are configuration properties for databases and mailing (JavaMailSender).