OnEveryThingIn progressQuantum Red themeBachelor’s Project

OnConnect

OnConnect combines a Qt desktop client with a C++ server, shared domain components and PostgreSQL persistence. Its modules cover accounts and permissions, direct and group chats, reactions, media sharing, a social feed, stories, reels, notifications, maps, reminders and administrative moderation. HTTP/JSON powers the API and a WebSocket relay carries call media; Cloudflare Tunnel is part of the documented deployment model. The custom OnConnect-Core C++ library collects reusable domain entities, DTOs and service contracts shared across the application.

C++Qt 6Qt WidgetsPostgreSQLWebSocketSQLiteOpenAIOnConnect-Core
ONOnConnect
C++Main technology
867Tracked files*
365.h files
267.cpp files
01 · What it does

What the application does

Capabilities evidenced by project documentation and source structure; some behaviours require platform configuration.

01

Accounts, profiles & permissions

User profiles, session state and role-related permissions form the identity layer. The desktop client provides the forms; the server must decide which records and actions each authenticated user may access.

A profile view starts from a session-bound account, then combines the selected profile with access rules. In practice, showing an edit button in the desktop UI is only presentation; the service has to check ownership again when saving.

  • Profile details and visibility can depend on the relationship between the viewer and the owner.
  • A role can permit a moderation action without granting permission to modify another account arbitrarily.
02

Friends & conversations

Private conversations and group conversations are distinct workflows. A conversation identifies its members, while individual messages carry content and optional references to media, replies or reactions.

A direct thread has a defined set of participants; a group adds membership changes and shared conversation state. A reply references an existing message, so both the reference and the current sender’s access need to be checked.

  • A reaction modifies message-associated state rather than replacing message content.
  • Forwarding needs an explicit destination and should not silently bypass source access rules.
  • Group participants must be checked when querying historical messages.
03

Feed, stories & reels

Publishing covers persistent posts, comments and saved items alongside more time-oriented stories and short videos. These surfaces share user identity but need different retrieval and presentation rules.

A social post carries its author, content and publication visibility; stories and short videos add different presentation and lifetime expectations. Feed retrieval is therefore a viewer-specific query, not simply “return every record”.

  • Comments, saves and reports affect associated records but have different permissions.
  • Uploaded media metadata should remain consistent when a post is edited or removed.
04

Calls & WebSocket media relay

The documented calling subsystem uses WebSocket-based relay/signalling with server mediation. It should not be described as a complete peer-to-peer WebRTC implementation.

Call traffic and ordinary chat history follow different paths. The documented WebSocket relay mediates call transport and signaling, while stored messages use the HTTP API and persistent models. These are separate responsibilities, even when the same conversation starts the call.

  • A call session should establish who may join and how reconnects are handled.
05

Notifications & updates

Notifications tie events in several modules back to the desktop interface. The current design documents incremental updates/polling rather than an assumption that every event is pushed instantly.

Several areas can produce updates: a new conversation event, a profile or friendship change, or a moderation decision. Polling or incremental refresh reads changes since a previous state; it is not equivalent to claiming the whole product uses push notifications.

  • Unread counters and event visibility should remain consistent after reconnect.
  • The client needs predictable behaviour when a refresh request fails.
06

Attachments & media handling

The client associates files with messages or posts, while backend upload endpoints accept media and provide metadata for persistence. Source excerpts show extension-based media categorisation, which is not a substitute for validating file contents.

Media handling involves more than displaying a filename. The user selects a file, upload logic transmits its bytes or chunks, and the server associates the stored result with a message or post only after validating the request.

  • Extension-based classification chooses a display category, not a trusted content type.
  • A stored attachment must not be retrievable merely because someone knows its path.
  • Incomplete chunks should be cleaned up or safely resumed.
07

Maps, routing & organisation

Location features sit alongside notes, reminders and related personal tools. The repository documentation separates marker updates from route computation through Observer and Strategy design concepts.

Map state is separate from the algorithm selected to compute a route. Observer-style marker updates help refresh views, while the Strategy abstraction allows route-search algorithms to be changed without rewriting the screen.

  • Location visibility matters independently of path-finding.
  • A reminder or note is personal data and requires account-scoped retrieval.
08

AI-assisted review & administration

The architecture documents AI-supported evaluation of content, combined with reporting and moderation tools. Generated assessments should inform the review workflow instead of silently becoming final policy decisions.

An AI assessment can assist a reviewer, but it should not silently become a final moderation decision. The system needs to preserve who reported content, the review outcome and the state transition used by an administrator.

  • Reports and automated assessments are distinct evidence sources.
  • An administrator needs an auditable reason when changing the review state.
  • Provider failures must not be treated as approval.
BACHELOR’S THESIS · 2026

OnConnect — bachelor’s thesis

Developed as a Computer Science bachelor’s thesis at Transilvania University of Brașov and presented at AFCO and SCSS. The project brings together the C++ domain model, PostgreSQL-backed services, a Qt desktop client, real-time features and moderation tools.

C++ / Qt desktop applicationHTTP/JSON API and PostgreSQLWebSocket media relaySocial and messaging modules
02 · Technical structure

How the system works

Technical architecture drawn from the repository and supplied documentation.

01

OnConnect-Core owns entities, services, domain rules, repository contracts and transfer objects.

02

OnConnect-Server implements PostgreSQL repositories and exposes HTTP/JSON routes; upload sessions reconstruct large media in chunks.

03

OnConnect-Client is a Qt Widgets desktop front end with navigation, themed pages and typed API clients.

04

OnConnect-Tests checks services, contracts, server routes and representative integration flows.

05

Notifications use incremental polling; calls use a server-mediated WebSocket media relay rather than complete WebRTC.

06

Location/map tools use Observer for refreshing markers and Strategy to select routing engines.

01 · Desktop action

A Qt Widgets page collects a user action (sign-in, new message, media selection or post). Its API client creates the request and handles the visible loading/error states.

02 · API and domain processing

The C++ server receives the HTTP/JSON call. Shared DTOs define the payload, while the service checks ownership, membership and permissions before delegating persistence to a repository.

03 · Persisted result and update

PostgreSQL holds the corresponding data and relationships. The response is mapped back into UI state; incremental notifications or refresh logic bring other screens into sync where documented.

04 · Tests and failure boundaries

OnConnect-Tests is the dedicated place for service/contract checks. Authentication failures, invalid payloads, missing media and unauthorized conversation access must have predictable outcomes.

System architecture · responsibilities

A conceptual view of the documented project layout. Arrows show intended data flow; they do not imply that every integration has been production-validated.

OnConnect-ClientQt 6 Widgets · desktop UIPages · forms · API requests
HTTP / JSON →
OnConnect-ServerC++ API · servicesValidation · permissions · uploads
Repositories →
PostgreSQLPersistent recordsAccounts · messages · posts
OnConnect-CoreShared domain objects, DTOs and service contracts used across the solution
OnConnect-TestsChecks for service rules, contracts and representative integration paths

Cloudflare Tunnel is a documented deployment component. WebSocket media relay and incremental notification updates represent separate runtime paths, not extra databases.

Example sequence · sending a message

This diagram explains the division of responsibilities; it is not a recording of live traffic.

  1. Qt clientCollects text, selected conversation and optional attachment references.
  2. API handlerReceives a structured request and validates the session and input.
  3. Domain serviceChecks conversation membership, message relationships and permitted actions.
  4. RepositoryWrites the message and its metadata into PostgreSQL.
  5. UI refreshRenders the response; other views obtain updates through documented refresh mechanisms.

Authorization and file-content validation are security boundaries to verify, not guarantees made by the visual diagram.

PROJECT WALKTHROUGH

Modules & engineering details

A module-by-module explanation of responsibilities, typical data flow and implementation boundaries. These descriptions reflect the documented architecture; they are not runtime certification.

01

Domain boundaries and shared C++ types

The shared C++ library is the contract boundary between client and server. The data model represents entities and request/response DTOs; service interfaces make domain operations explicit without forcing the Qt screen or a database query to define the business model.

Why the split matters

A field or operation should have one clearly defined contract; otherwise client and backend can disagree about what a request means.

  • Model and transport changes should be reviewed together.
  • Keep data-access details out of the desktop UI.
02

Authentication, relationships and visibility

A successful authentication step establishes a context for subsequent requests; it does not grant unlimited access. The server should combine the account, its role and the visibility rules for the resource. Friend relationships affect discoverability and profile access.

Example check

When a user opens a private profile, a successful login is not enough: the server evaluates the target profile, viewer relationship and visibility before returning fields.

  • Validate every protected read or mutation.
03

Messaging and group membership

Message transmission combines an API-level action, a membership rule, stored conversation records and rendering in the Qt UI. Direct and group chats share messaging concepts but differ in participant handling, invitations and member changes.

State consistency

The same message may appear in multiple participants’ views. Its database identity, reply relationship and reaction state need consistent interpretation across API responses.

  • Handle missing or deleted referenced messages safely.
  • Re-check group membership for attachment access.
04

Feed, stories and short-form media

The publishing workflow has to serve several different surfaces: an ordinary post, a saved item, a temporary story and a reel. They can share author/media references while keeping their own lifetime, ordering, visibility and moderation semantics.

Publishing lifecycle

Creating a post, finding it in a personalized feed, reporting it and moderating it are separate operations. Keeping them separate simplifies both permissions and testing.

  • Consider visibility and expiration when retrieving stories.
05

Media, uploads and calls

The attachment classifier shown below maps filename extensions to image, video, audio or generic file categories. Upload endpoints also document chunked transport. WebSocket relay is separately documented for calls and must not be confused with persistent message attachment storage.

Upload boundary

File metadata is useful for presentation, but trusted validation belongs to the backend. A failed upload should not create an apparently valid attachment record.

  • Distinguish temporary upload state from committed media.
  • Relay sessions have different access rules from persistent files.
06

Maps, route selection and personal utilities

The map design uses separation of concerns: marker collections are refreshed through observer-style updates, while routing algorithms are selected through a strategy interface. Personal organisation tools add notes, reminders and alarms without turning them into social posts.

Abstraction in practice

The view asks for route computation through a strategy interface; it should not embed one search algorithm into button event handlers. Marker refreshes are view updates, not automatically a map service API.

  • Separate algorithm choice from map rendering.
07

AI assistance and administrative review

An administrative review starts with reported material, not an AI verdict. A classifier may support prioritisation, while an administrator can inspect context, apply policy and record the decision. These are separate stages in the documented design.

Human decision point

The AI service can produce a status or priority; a reviewer applies the outcome using authenticated administrative actions. Failure, pending review and rejection are not interchangeable.

  • Keep a traceable review state and reason.
  • Protect administrative endpoints independently of UI roles.
08

Deployment, trust boundaries and testing

Qt desktop pages call HTTP/JSON endpoints exposed by the C++ server. PostgreSQL provides persistence, while a Cloudflare Tunnel appears in the deployment documentation. Tests are a distinct project for contracts and representative integrations.

Deployment boundary

Exposing the API through a tunnel changes connectivity, not the trust model. Authentication and request validation are still enforced inside the server, including download and relay endpoints.

  • Use runtime secrets rather than committing credentials.
09

Security and production roadmap

The security roadmap explicitly names areas that require production hardening. It must be read as work remaining or needing verification, not as evidence that every listed control is already deployed.

Risk register

Before a public release, security work should be closed with evidence such as tests, configuration reviews and a targeted abuse-case checklist—not just the presence of a roadmap document.

  • Treat authentication bypass and unauthorized media reads as release blockers.
  • Test validation of unexpected content and oversized uploads.
10

Verification matrix and release readiness

The architecture separates user-interface behaviour, domain rules, persistence and media transport. A useful release gate tests each boundary independently and then exercises end-to-end flows; passing a single UI demonstration is not enough to validate the system.

Release evidence

A demonstration shows that one supported scenario can work. A release matrix also tests errors, unauthorized access, state recovery and interfaces shared by client, server and Core.

  • Test both successful and rejected API paths.
  • Run integration checks against a controlled test database.

OnConnect-Core: contracts and runtime responsibilities

The source tree contains IChatService, ChatService and repository interfaces. Their separation is more valuable to explain than another generic description of C++ or Qt.

01

Interfaces and dependency injection

IChatService defines an abstraction for chat operations; ChatService is an implementation constructed with a chat repository and a date/time provider. This allows domain logic to be understood without coupling it directly to widgets.

02

Desktop request boundary

Qt client widgets collect input and form requests; service and server-side authorization should determine which records or conversations a user may access.

03

Media handling and transport

Attachment categorisation, media metadata and the WebSocket-based call relay are separate concerns from HTTP/JSON records. File extensions by themselves do not prove uploaded content is safe.

04

Tests, deployment and audit trail

OnConnect-Tests is the stated place for shared-contract and representative integration checks. The documented security-hardening roadmap remains open and must be described as work requiring verification.

The public-facing repository README currently contains only its title; this overview also uses source paths in OnConnect-Core and earlier project documentation.

Documentation: GitHub repository / project specification. The content describes documented behaviour or plans; deployment readiness is not inferred.

03 · Explore

Project-specific preview

Illustrative chat interfaceStatic example · not connected to a server
Your project files are ready for review.
I will check the architecture and respond.
Sounds good — let’s keep all updates organized.
Visual studies · project-specific

Interface and system concepts

Independent illustrative views of the documented or proposed workflows. They are not connected to a running backend, and their values are not actual measurements.

Modelled desktop layer · illustrative

Account and permission workspace

The interface can show account fields and edit options, but the server still needs to validate ownership, role and profile visibility before returning or saving data.

SessionProfileVisibilityPermissions
Modelled message interface · illustrative

Conversation and media workspace

FriendsGroup projectMedia thread
Message received · 10:21
Reply with attachment
Shared conversation preview

Conversation membership provides the context for messages, reactions and attachments; account ownership and destination membership are checked by the service layer.

FriendsGroup chatReplyAttachment
Modelled dashboard · illustrative

Publishing and moderation board

Post content and mediaVisibility · followers
Review queue
AI assessment

Publishing, reporting and moderation remain separate workflow stages. A feed item can carry author and media metadata while a review queue preserves evidence and review state.

DraftMediaReportsReview state
Modelled route view · illustrative

Location and routing workspace

A map can render markers and a computed route; a selected graph-search strategy decides how the conceptual path is derived and updated independently of marker refresh.

MarkersStrategyObserverPath
Media transport mockup · illustrative

Upload and gallery lifecycle

Chunk 1
Chunk 2
Link record

Large attachments can be uploaded in parts before the server reconstructs the file and links it to a message or post. Retrieval permissions remain independent from the upload itself.

ChunksRebuildMetadataGallery
System flow · illustrative

Service boundaries and release checks

Qt clientHTTP / JSONC++ servicesPostgreSQL
APIOwnershipUploadsTests

Requests cross a service boundary before persistence. Release readiness depends on denied-action tests, invalid payload checks, upload failure handling and representative integration paths.

ClientServerDatabaseTests
Media intelligence · illustrative

Image processing and moderation cues

Scan
Faces2 detected
Labelsstreet · winter
Moderation checkImage labelsIdentity hint

Optional image analysis can remain a helper step rather than an authority: media labels, face-detection cues or moderation suggestions would still need application rules and review context.

ScanLabelsDetectionReview
Owner analytics · illustrative

Content share by activity type

ReelsPostsMessages

An owner-side panel could summarize how activity is distributed across publishing and messaging surfaces without confusing high-level trends with moderation decisions.

OwnerReelsPostsMessages
Subsystem map · illustrative

Core, Server, Client and Tests

OnConnect-Coreentities · DTOs · contracts
OnConnect-ServerPostgreSQL · API · auth
OnConnect-ClientQt pages · themes · navigation
OnConnect-Testsunit · integration · validation

The four main code areas stay separated so shared models, API services, desktop UI concerns and verification work can evolve without becoming the same project responsibility.

CoreServerClientTests
04 · Source and design

Implementation examples and code walkthrough

Network request configuration in the Qt desktop client

OnConnect/OnConnect-Client/ApiClient.cppGitHub code excerpt
static void ConfigureApiRequest(QNetworkRequest& req, int timeoutMs = 60000)
{
    req.setAttribute(QNetworkRequest::Http2AllowedAttribute, false);
#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0)
    req.setTransferTimeout(timeoutMs);
#endif
}

Classifying attachment media

C++

A shared service maps attachments to a media category before saving message metadata.

OnConnect/OnConnect-Core/ChatService.cppSelected source excerpt
MediaType ChatService::DetectMediaType(const QString& mediaPath)
{
    if (mediaPath.trimmed().isEmpty())
        return MediaType::File;
    const QString p = mediaPath.toLower();
    if (p.endsWith(".png") || p.endsWith(".jpg") || p.endsWith(".jpeg") || p.endsWith(".webp")) return MediaType::Image;
    if (p.endsWith(".mp4") || p.endsWith(".mov") || p.endsWith(".mkv")) return MediaType::Video;
    if (p.endsWith(".mp3") || p.endsWith(".wav") || p.endsWith(".ogg")) return MediaType::Audio;
    return MediaType::File;
}

Moderation requires review state

C++

The moderation aggregator ranks rejection and pending review above approval; automatic service output is not the final policy decision.

OnConnect/OnConnect-Core/AIModerationService.cppSelected source excerpt
static int AggregatePriority(const AIModerationResult& r)
{
    if (r.Status == AIModerationStatus::RejectedByAI || r.Decision == AIModerationDecision::Reject)
        return 50;
    if (r.Status == AIModerationStatus::Pending || r.Decision == AIModerationDecision::None)
        return 45;
    if (r.Status == AIModerationStatus::NeedsReview || r.Decision == AIModerationDecision::Review)
        return 40;
    if (IsProviderFailureStatus(r.Status))
        return 35;
    return r.Status == AIModerationStatus::Approved ? 10 : 0;
}

Reading these examples in context. The first excerpt prepares a Qt network request, including timeout behaviour; it does not implement sign-in by itself. The attachment classifier groups known file extensions into image, video and audio categories, which helps choose UI treatment but does not verify the actual bytes or authorize downloads. The moderation excerpt gives rejection and pending-review states higher priority than an approved result. These examples show individual rules; service integration, persistence and access checks must be understood from their respective source files.

Code samples are excerpts or documented illustrations; surrounding project files, configuration and dependencies may be required to compile or run them.

ENGINEERING NOTES

Design decisions & failure scenarios

The architecture is easier to evaluate by looking at responsibilities, the state that crosses a boundary and what happens when a step fails. These are design considerations grounded in the documented modules, not claims of a completed production audit.

Authorization before retrieval

The same request may be valid for one viewer and forbidden for another. The server must decide what is readable and writable before returning personal or group data.

  • Check membership and ownership server-side.
  • Test access after leaving a group.

Reliable message state

Message creation and conversation refresh are separate phases. The UI needs to reconcile the stored server result with its local view, including failures and duplicate submissions.

  • Track stable message identifiers.
  • Handle retry and refresh without duplicating content.

Media and call boundaries

Uploaded files become persistent resources only after server-side checks. A call relay is a runtime session and should not reuse file-download permissions by accident.

  • Validate the data, not only its extension.
  • Handle interrupted uploads and disconnected calls.

Observability and testing

Service tests establish domain rules, while route and database tests check integration. Reviewable logs and explicit errors make it possible to trace failures across layers.

  • Avoid logging sensitive credentials or media.
  • Include denied-action and recovery cases in the test matrix.
06 · Technology

Programming languages & stack

OpenAIAWS Rekognition
C++
Qt 6
Qt Widgets
Qt Network
QSS
HTTP/JSON
PostgreSQL
WebSocket
SQLite
Cloudflare Tunnel
OnConnect-Core

Core technologies and integrations used or planned for this project.

File types identified: 365 .h, 267 .cpp, 203 .json

07 · Reality check

Status, evidence & limitations

The project status is based on repository sources and supplied documentation. It may be updated as the project evolves. A published case study is not a certification of production readiness.
  • A previous 2026 technical audit identified security-hardening work before any production release; implementation claims do not certify a secure deployment.
  • Calls use the documented WebSocket media relay, not full peer-to-peer WebRTC.
  • This site does not publish server endpoints, private repository contents, connection strings or secrets.
08 · Resources

Downloads & project resources

Installers appear only after a verified release is added to the public download directory. Unavailable builds are marked clearly.

↓Windows EXEComing soon↓Android APKComing soon
Source and platform support may change. An installer is not implied by the existence of source files. Desktop and Android package placeholders are shown until verified releases are published.