jandres/Temp_MSSPLASHPage
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

changes: Add Meraki sincronization service

Browse Source
This commit is contained in:
Jose Andres
2025-11-19 10:16:43 -06:00
parent 739baab0a4
commit 7bed77d290
7 changed files with 917 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

485
changelog.MD
View File

@@ -5,6 +5,491 @@ Consulta este archivo al inicio de cada sesión para entender el contexto y prog
---
## 2025-11-19 - Feature: Meraki Network Name Synchronization Endpoint ✅
### 🔄 Network Name & Access Point Synchronization API
**Objective**: Create an API endpoint to synchronize Meraki network names with local database, with preview mode and optional AP synchronization.
**Problem**: Network names in the local database could become out of sync with Meraki when networks are renamed in the Meraki Dashboard. There was no easy way to see which networks had name differences or to bulk update them.
**Solution**: Implemented a new endpoint `SyncNetworkNamesAsync` in the Location Scanning service with the following features:
### Key Features:
1. **Preview Mode** (`Process = false`): Shows differences without applying changes
2. **Execution Mode** (`Process = true`): Actually updates network names in database
3. **AP Synchronization** (`ProcessAPs = true`): Optionally syncs Access Points (requires `Process = true`)
4. **Detailed Statistics**: Returns comprehensive information about networks and APs
### API Endpoint:
```
POST /api/services/app/SplashLocationScanning/SyncNetworkNames
Authorization: Bearer {token}
Body: {
"process": false, // true = apply changes, false = preview only
"processAPs": false // true = sync APs (only if process=true)
}
```
### Response Structure:
```json
{
"processExecuted": false,
"apsProcessExecuted": false,
"totalNetworksInMeraki": 25,
"totalNetworksLocal": 25,
"networksWithNameChanges": 3,
"networksUnchanged": 22,
"changes": [
{
"networkId": 123,
"merakiId": "N_123456",
"oldName": "Oficina Principal",
"newName": "Oficina Principal - Piso 1",
"organizationName": "Mi Organización",
"localAPCount": 0,
"merakiAPCount": 8,
"missingAPCount": 8,
"apsSynchronized": false
}
],
"totalAPsInMeraki": 150,
"totalAPsLocal": 0,
"missingAPsCount": 150,
"synchronizedAPsCount": 0,
"errors": []
}
```
### Files Created:
#### 1. **src/SplashPage.Application/Splash/Dto/SyncNetworkNamesInput.cs**
Input DTO with two boolean properties:
- `Process`: Execute updates (default: false)
- `ProcessAPs`: Sync Access Points (default: false, requires Process=true)
#### 2. **src/SplashPage.Application/Splash/Dto/SyncNetworkNamesResultDto.cs**
Two DTOs for comprehensive results:
- `NetworkChangeDto`: Details for each network with name differences
- Network IDs (local and Meraki)
- Old and new names
- Organization name
- AP counts (local, Meraki, missing)
- AP synchronization status
- `SyncNetworkNamesOutput`: Overall sync statistics
- Execution flags
- Network counts and statistics
- AP counts and statistics
- List of all changes
- Error messages
### Files Modified:
#### 3. **src/SplashPage.Application/Splash/ISplashLocationScanningAppService.cs**
Added method signature:
```csharp
Task<SyncNetworkNamesOutput> SyncNetworkNamesAsync(SyncNetworkNamesInput input);
```
#### 4. **src/SplashPage.Application/Splash/SplashLocationScanningAppService.cs**
Implemented full synchronization logic:
- Groups networks by organization
- Fetches current data from Meraki API per organization
- Retrieves wireless devices (APs) from Meraki
- Compares local vs Meraki network names
- Counts APs per network (filters by "MR" model prefix)
- Applies updates only if `Process = true`
- Tracks detailed statistics and errors
- Uses ABP authorization and UnitOfWork patterns
### Implementation Details:
**Network Synchronization Process:**
1. Get tenant API key from `SplashTenantDetails`
2. Load all local networks with organization info (eager loading)
3. Group networks by Meraki organization ID
4. For each organization:
- Call `GetOrganizationNetworks()` to get current Meraki networks
- Call `GetOrganizationDevices(type: "wireless")` to get all APs
- Match local networks with Meraki networks by `MerakiId`
- Count APs per network (filter by Model starting with "MR")
- Compare names and track differences
- If `Process=true`: Update network names and metadata
5. Save changes to database (only if Process=true)
6. Return comprehensive statistics
**AP Counting Logic:**
- Filters devices where `Model` starts with "MR" (Meraki Access Points)
- Matches devices to networks using `NetworkId`
- Currently returns counts only (AP entity persistence is TODO)
**Best Practices Used:**
- ✅ Reuses existing `MerakiService` for API calls
- ✅ Follows ABP framework patterns (repositories, UnitOfWork, authorization)
- ✅ Implements preview mode for safe verification before changes
- ✅ Comprehensive error handling with try-catch at multiple levels
- ✅ Detailed logging for debugging
- ✅ Multi-tenant aware (uses TenantId filtering)
- ✅ Soft-delete aware (excludes deleted networks)
- ✅ Efficient queries with eager loading (`.Include()`)
- ✅ Uses `Clock.Now` for consistent timestamps
- ✅ Tracks modification user via `AbpSession.UserId`
### Usage Example:
**Step 1 - Preview changes:**
```bash
POST /api/services/app/SplashLocationScanning/SyncNetworkNames
{ "process": false, "processAPs": false }
```
Response shows all network name differences without applying changes.
**Step 2 - Apply changes:**
```bash
POST /api/services/app/SplashLocationScanning/SyncNetworkNames
{ "process": true, "processAPs": false }
```
Updates network names in database.
**Step 3 - Apply changes + sync APs:**
```bash
POST /api/services/app/SplashLocationScanning/SyncNetworkNames
{ "process": true, "processAPs": true }
```
Updates network names and marks APs as synchronized (AP persistence is TODO).
### Future Enhancements:
- Implement full AP entity persistence when `ProcessAPs = true`
- Add support for other device types beyond APs
- Add batch size limits for large organizations
- Add progress reporting for long-running syncs
### 🔧 Fix: Correct AP Counting Using SplashAccessPoint Entity
**Date**: 2025-11-19 (same day update)
**Problem**: Initial implementation had incorrect AP counting logic:
- Used wrong property names (`d.NetworkId` instead of `d.networkId`, `d.Model` instead of `d.model`)
- Didn't query local `SplashAccessPoint` table, incorrectly assumed no local APs existed
- Set `LocalAPCount = 0` and `MissingAPCount = merakiAPCount` without checking database
**Solution**: Updated AP counting to use the actual `SplashAccessPoint` entity:
**Changes Made:**
1. **Added Repository Dependency** (`SplashLocationScanningAppService.cs`):
- Injected `IRepository<SplashAccessPoint, int>` into service constructor
- Added `_accessPointRepository` private field
2. **Fixed AP Counting Logic** (lines 471-493):
```csharp
// Get Meraki APs for specific network (fixed property names)
var merakiAPsForNetwork = allOrgDevices?
.Where(d => d.networkId == localNetwork.MerakiId &&
!string.IsNullOrEmpty(d.model) &&
d.model.StartsWith("MR", StringComparison.OrdinalIgnoreCase))
.ToList() ?? new List<MerakiNetworkDevice>();
// Query local APs from database
var localAPs = await _accessPointRepository
.GetAllReadonly()
.Where(ap => ap.NetworkId == localNetwork.Id && !ap.IsDeleted)
.ToListAsync();
int localAPCount = localAPs.Count;
// Match by Serial field (unique identifier)
int missingAPCount = merakiAPsForNetwork
.Count(merakiAP => !localAPs.Any(localAP => localAP.Serial == merakiAP.serial));
```
3. **Updated NetworkChangeDto** (lines 507-509):
- Changed `LocalAPCount` from hardcoded `0` to actual `localAPCount`
- Changed `MissingAPCount` from `merakiAPCount` to calculated `missingAPCount`
4. **Fixed Final Statistics** (line 561):
- Removed incorrect lines that set `TotalAPsLocal = 0`
- Changed to: `output.MissingAPsCount = output.Changes.Sum(c => c.MissingAPCount)`
- Now `TotalAPsLocal` is accumulated correctly in the loop
**Key Improvements:**
✅ Uses actual `SplashAccessPoint` entity from database
✅ Matches APs by `Serial` field (correct unique identifier)
✅ Calculates accurate missing count (Meraki APs not in local DB)
✅ Respects soft-delete pattern (`!ap.IsDeleted`)
✅ Fixed Meraki DTO property names (`d.networkId`, `d.model`, `d.serial`)
✅ Provides accurate per-network and total statistics
**Result**: The endpoint now returns correct AP counts showing real synchronization status.
### 🎯 Enhancement: Add NetworkHasDiff Flag and OnlyShowDiff Filter
**Date**: 2025-11-19 (same day update)
**Problem**:
- `APsSynchronized` field was confusing - it was always set to `false` and only changed to `true` during `ProcessAPs` execution
- No way to tell if a network has ANY differences (name OR APs)
- No filter to show only networks with differences vs all networks
**Solution**: Added two new features to improve clarity and usability:
**1. Added `NetworkHasDiff` Field to `NetworkChangeDto`:**
```csharp
/// <summary>
/// Indica si la red tiene alguna diferencia (nombre diferente O APs faltantes).
/// true = La red necesita atención (nombre cambió O faltan APs)
/// false = La red está completamente sincronizada (nombre Y APs coinciden)
/// </summary>
public bool NetworkHasDiff { get; set; }
```
**Calculation Logic:**
```csharp
bool nameChanged = (localNetwork.Name != merakiNetwork.Name);
bool apsAreSynced = (missingAPCount == 0);
bool networkHasDiff = nameChanged || !apsAreSynced;
```
**2. Fixed `APsSynchronized` Field Logic:**
- **Before**: Always `false`, only set to `true` when executing `ProcessAPs`
- **After**: Reflects actual sync status: `true` when `missingAPCount == 0`, `false` otherwise
Updated documentation:
```csharp
/// <summary>
/// Indica si los APs están completamente sincronizados (missingAPCount == 0).
/// true = Todos los APs de Meraki están en la DB local
/// false = Hay APs en Meraki que no están en la DB local
/// </summary>
public bool APsSynchronized { get; set; }
```
**3. Added `OnlyShowDiff` Filter to `SyncNetworkNamesInput`:**
```csharp
/// <summary>
/// Indica si solo se deben mostrar redes con diferencias.
/// false = Mostrar todas las redes (con y sin cambios)
/// true = Mostrar solo redes con diferencias (nombre diferente O APs faltantes)
/// </summary>
public bool OnlyShowDiff { get; set; } = true; // Default: show only diffs
```
**Filter Implementation:**
```csharp
// Apply OnlyShowDiff filter
if (!input.OnlyShowDiff || networkHasDiff)
{
// Include this network in the response
output.Changes.Add(new NetworkChangeDto { ... });
}
```
**Files Modified:**
1. `SyncNetworkNamesInput.cs` - Added `OnlyShowDiff` property (default: true)
2. `SyncNetworkNamesResultDto.cs` - Added `NetworkHasDiff`, updated `APsSynchronized` documentation
3. `SplashLocationScanningAppService.cs` - Updated logic to:
- Calculate `apsAreSynced` based on `missingAPCount == 0`
- Calculate `networkHasDiff` as `nameChanged || !apsAreSynced`
- Apply `OnlyShowDiff` filter
- Set both flags correctly in the response
**Example Response:**
```json
{
"changes": [
{
"networkId": 123,
"oldName": "Office",
"newName": "Office",
"localAPCount": 5,
"merakiAPCount": 5,
"missingAPCount": 0,
"apsSynchronized": true, // ← APs fully synced
"networkHasDiff": false // ← No differences at all
},
{
"networkId": 124,
"oldName": "Warehouse",
"newName": "Warehouse - Building A",
"localAPCount": 3,
"merakiAPCount": 8,
"missingAPCount": 5,
"apsSynchronized": false, // ← APs NOT synced (5 missing)
"networkHasDiff": true // ← Has differences (name AND APs)
}
]
}
```
**Usage Examples:**
Show only networks with differences (default):
```json
POST /api/services/app/SplashLocationScanning/SyncNetworkNames
{ "process": false, "onlyShowDiff": true }
```
Show ALL networks (even those without changes):
```json
POST /api/services/app/SplashLocationScanning/SyncNetworkNames
{ "process": false, "onlyShowDiff": false }
```
**Benefits:**
✅ Clear distinction between sync status and differences
✅ `NetworkHasDiff` shows if network needs attention
✅ `APsSynchronized` accurately reflects AP sync status
✅ `OnlyShowDiff` filter reduces noise in response
✅ Default behavior shows only networks that need action
### 🚀 Implementation: Access Point Synchronization
**Date**: 2025-11-19 (same day update)
**Problem**: The TODO comment for AP synchronization was never implemented - when `ProcessAPs = true`, the code only counted missing APs but didn't actually create them in the database.
**Solution**: Implemented full AP synchronization logic that creates missing `SplashAccessPoint` entities in the database.
**Implementation Details:**
**File**: `SplashLocationScanningAppService.cs` (lines 536-581)
```csharp
if (input.Process && input.ProcessAPs && !apsAreSynced)
{
try
{
// Find APs in Meraki but NOT in local DB (match by Serial)
var missingAPs = merakiAPsForNetwork
.Where(merakiAP => !localAPs.Any(localAP => localAP.Serial == merakiAP.serial))
.ToList();
if (missingAPs.Any())
{
// Create new SplashAccessPoint entities
foreach (var merakiAP in missingAPs)
{
var newAccessPoint = new SplashAccessPoint
{
Serial = merakiAP.serial, // Unique identifier
Mac = merakiAP.mac,
Name = merakiAP.name,
Model = merakiAP.model,
Latitude = merakiAP.lat?.ToString(),
Longitude = merakiAP.lng?.ToString(),
NetworkId = localNetwork.Id, // FK to local network
LanIP = merakiAP.lanIp,
CreationTime = Clock.Now
};
await _accessPointRepository.InsertAsync(newAccessPoint);
output.SynchronizedAPsCount++;
}
// Persist to database
await CurrentUnitOfWork.SaveChangesAsync();
// Update status
change.APsSynchronized = true;
change.NetworkHasDiff = nameChanged; // Only name diff remains
}
}
catch (Exception ex)
{
output.Errors.Add($"Error sincronizando APs de red '{localNetwork.Name}': {ex.Message}");
Logger.Error($"Error syncing APs for network {localNetwork.Id}", ex);
}
}
```
**Field Mapping from Meraki to SplashAccessPoint:**
- `serial` → `Serial` (unique identifier, used for matching)
- `mac` → `Mac`
- `name` → `Name`
- `model` → `Model`
- `lat` → `Latitude` (converted to string)
- `lng` → `Longitude` (converted to string)
- `lanIp` → `LanIP`
- Meraki `networkId` → Resolved to local database `NetworkId` (FK)
- `CreationTime` → Set using ABP's `Clock.Now`
**Workflow:**
1. Check if `ProcessAPs = true` and APs are not synced (`!apsAreSynced`)
2. Find APs in Meraki that don't exist locally (compare by `Serial`)
3. For each missing AP:
- Create new `SplashAccessPoint` entity
- Map all fields from Meraki device
- Link to local network via `NetworkId` FK
- Insert into database
- Increment `SynchronizedAPsCount`
4. Save all changes with `CurrentUnitOfWork.SaveChangesAsync()`
5. Update status flags:
- `APsSynchronized = true` (APs now synced)
- `NetworkHasDiff = nameChanged` (only name diff remains, if any)
6. Error handling: Catches exceptions per network to prevent cascade failures
**Usage Example:**
```json
POST /api/services/app/SplashLocationScanning/SyncNetworkNames
{
"process": true,
"processAPs": true,
"onlyShowDiff": true
}
```
**Response:**
```json
{
"processExecuted": true,
"apsProcessExecuted": true,
"synchronizedAPsCount": 12, // ← Actual APs created in database
"changes": [
{
"networkId": 124,
"oldName": "Warehouse",
"newName": "Warehouse - Building A",
"localAPCount": 3,
"merakiAPCount": 8,
"missingAPCount": 5,
"apsSynchronized": true, // ← Changed from false to true after sync
"networkHasDiff": true // ← Still true (name changed)
}
],
"errors": []
}
```
**Key Features:**
✅ Creates missing APs in database (not just counting)
✅ Matches by `Serial` field (follows existing pattern from `DataMigrationService`)
✅ Maps all relevant fields from Meraki API
✅ Links APs to networks via FK relationship
✅ Bulk saves for efficiency
✅ Per-network error handling (one network failure doesn't break others)
✅ Updates `APsSynchronized` status after successful sync
✅ Recalculates `NetworkHasDiff` after AP sync
✅ Tracks actual synchronized count in `SynchronizedAPsCount`
**Before vs After:**
**Before** (`ProcessAPs = true`):
- Only incremented counter: `output.SynchronizedAPsCount += missingAPCount`
- No database changes
- TODO comment indicated missing implementation
**After** (`ProcessAPs = true`):
- Creates actual `SplashAccessPoint` entities
- Persists to database with all fields
- Updates status flags accurately
- Proper error handling and logging
- Returns real synchronized count
This completes the full implementation of the network name and AP synchronization endpoint! 🎉
---
## 2025-11-19 - Feature: Color Theme Configuration via Environment Variables ✅
### 🎨 Environment Variable Support for Default Color Themes

30
src/SplashPage.Application/Splash/Dto/SyncNetworkNamesInput.cs Normal file
View File

@@ -0,0 +1,30 @@
namespace SplashPage.Splash.Dto
{
/// <summary>
/// Input DTO para la sincronización de nombres de redes de Meraki
/// </summary>
public class SyncNetworkNamesInput
{
/// <summary>
/// Indica si se debe ejecutar el proceso de actualización de nombres.
/// false = Solo preview (mostrar diferencias sin aplicar cambios)
/// true = Ejecutar actualización y aplicar cambios
/// </summary>
public bool Process { get; set; } = false;
/// <summary>
/// Indica si se deben sincronizar los Access Points de Meraki.
/// Solo tiene efecto si Process = true
/// false = No sincronizar APs
/// true = Sincronizar APs desde Meraki API
/// </summary>
public bool ProcessAPs { get; set; } = false;
/// <summary>
/// Indica si solo se deben mostrar redes con diferencias.
/// false = Mostrar todas las redes (con y sin cambios)
/// true = Mostrar solo redes con diferencias (nombre diferente O APs faltantes)
/// </summary>
public bool OnlyShowDiff { get; set; } = true;
}
}

137
src/SplashPage.Application/Splash/Dto/SyncNetworkNamesResultDto.cs Normal file
View File

@@ -0,0 +1,137 @@
using System.Collections.Generic;
namespace SplashPage.Splash.Dto
{
/// <summary>
/// DTO que representa un cambio en el nombre de una red
/// </summary>
public class NetworkChangeDto
{
/// <summary>
/// ID de la red en la base de datos local
/// </summary>
public int NetworkId { get; set; }
/// <summary>
/// ID de la red en Meraki
/// </summary>
public string MerakiId { get; set; }
/// <summary>
/// Nombre anterior de la red (valor local antes de sincronizar)
/// </summary>
public string OldName { get; set; }
/// <summary>
/// Nombre nuevo de la red (valor actual en Meraki)
/// </summary>
public string NewName { get; set; }
/// <summary>
/// Nombre de la organización a la que pertenece la red
/// </summary>
public string OrganizationName { get; set; }
/// <summary>
/// Cantidad de Access Points sincronizados localmente para esta red
/// </summary>
public int LocalAPCount { get; set; }
/// <summary>
/// Cantidad de Access Points reportados por Meraki API para esta red
/// </summary>
public int MerakiAPCount { get; set; }
/// <summary>
/// Cantidad de APs faltantes (MerakiAPCount - LocalAPCount)
/// Puede ser negativo si hay más APs locales que en Meraki
/// </summary>
public int MissingAPCount { get; set; }
/// <summary>
/// Indica si los APs están completamente sincronizados (missingAPCount == 0).
/// true = Todos los APs de Meraki están en la DB local
/// false = Hay APs en Meraki que no están en la DB local
/// </summary>
public bool APsSynchronized { get; set; }
/// <summary>
/// Indica si la red tiene alguna diferencia (nombre diferente O APs faltantes).
/// true = La red necesita atención (nombre cambió O faltan APs)
/// false = La red está completamente sincronizada (nombre Y APs coinciden)
/// </summary>
public bool NetworkHasDiff { get; set; }
}
/// <summary>
/// DTO para el resultado de la sincronización de nombres de redes con Meraki
/// </summary>
public class SyncNetworkNamesOutput
{
/// <summary>
/// Indica si el proceso de actualización fue ejecutado (true) o solo fue un preview (false)
/// </summary>
public bool ProcessExecuted { get; set; }
/// <summary>
/// Indica si los Access Points fueron sincronizados durante el proceso
/// </summary>
public bool APsProcessExecuted { get; set; }
/// <summary>
/// Total de redes encontradas en Meraki
/// </summary>
public int TotalNetworksInMeraki { get; set; }
/// <summary>
/// Total de redes en la base de datos local
/// </summary>
public int TotalNetworksLocal { get; set; }
/// <summary>
/// Cantidad de redes que tienen diferencias en el nombre
/// </summary>
public int NetworksWithNameChanges { get; set; }
/// <summary>
/// Cantidad de redes sin cambios en el nombre
/// </summary>
public int NetworksUnchanged { get; set; }
/// <summary>
/// Lista detallada de todos los cambios encontrados/aplicados
/// </summary>
public List<NetworkChangeDto> Changes { get; set; }
/// <summary>
/// Total de Access Points encontrados en Meraki (suma de todas las redes)
/// </summary>
public int TotalAPsInMeraki { get; set; }
/// <summary>
/// Total de Access Points sincronizados localmente (suma de todas las redes)
/// </summary>
public int TotalAPsLocal { get; set; }
/// <summary>
/// Cantidad total de APs faltantes por sincronizar
/// </summary>
public int MissingAPsCount { get; set; }
/// <summary>
/// Cantidad de APs que fueron sincronizados en esta operación (solo si ProcessAPs = true)
/// </summary>
public int SynchronizedAPsCount { get; set; }
/// <summary>
/// Lista de errores encontrados durante el proceso
/// </summary>
public List<string> Errors { get; set; }
public SyncNetworkNamesOutput()
{
Changes = new List<NetworkChangeDto>();
Errors = new List<string>();
}
}
}

9
src/SplashPage.Application/Splash/ISplashLocationScanningAppService.cs
View File

@@ -46,5 +46,14 @@ namespace SplashPage.Splash
/// </summary>
/// <returns>Resultado de la sincronización con estadísticas y errores</returns>
Task<SyncNetworkStatusOutput> SyncNetworkStatusAsync();
/// <summary>
/// Sincroniza los nombres de las redes locales con los nombres actuales en Meraki.
/// Soporta modo preview (solo mostrar diferencias) y modo ejecución (aplicar cambios).
/// Opcionalmente puede sincronizar también los Access Points de cada red.
/// </summary>
/// <param name="input">Parámetros de sincronización (Process, ProcessAPs)</param>
/// <returns>Resultado detallado con cambios de nombres y estadísticas de APs</returns>
Task<SyncNetworkNamesOutput> SyncNetworkNamesAsync(SyncNetworkNamesInput input);
}
}

255
src/SplashPage.Application/Splash/SplashLocationScanningAppService.cs
View File

@@ -28,19 +28,22 @@ namespace SplashPage.Splash
private readonly IMerakiService _merakiService;
private readonly IRepository<SplashTenantDetails, int> _tenantDetailsRepository;
private readonly IRepository<SplashMerakiOrganization, int> _organizationRepository;
private readonly IRepository<SplashAccessPoint, int> _accessPointRepository;
public SplashLocationScanningAppService(
IRepository<SplashLocationScanningConfig, int> repository,
IRepository<SplashMerakiNetwork, int> networkRepository,
IMerakiService merakiService,
IRepository<SplashTenantDetails, int> tenantDetailsRepository,
IRepository<SplashMerakiOrganization, int> organizationRepository)
IRepository<SplashMerakiOrganization, int> organizationRepository,
IRepository<SplashAccessPoint, int> accessPointRepository)
{
_repository = repository;
_networkRepository = networkRepository;
_merakiService = merakiService;
_tenantDetailsRepository = tenantDetailsRepository;
_organizationRepository = organizationRepository;
_accessPointRepository = accessPointRepository;
}
/// <summary>
@@ -366,5 +369,255 @@ namespace SplashPage.Splash
return output;
}
}
/// <summary>
/// Sincroniza los nombres de las redes locales con los nombres actuales en Meraki.
/// Soporta modo preview (solo mostrar diferencias) y modo ejecución (aplicar cambios).
/// Opcionalmente puede sincronizar también los Access Points de cada red.
/// </summary>
[AbpAuthorize(PermissionNames.Pages_Administration_LocationScanning_Edit)]
public async Task<SyncNetworkNamesOutput> SyncNetworkNamesAsync(SyncNetworkNamesInput input)
{
const int tenantId = 1; // Always use tenant 1 as specified
var output = new SyncNetworkNamesOutput
{
ProcessExecuted = input.Process,
APsProcessExecuted = input.ProcessAPs && input.Process
};
try
{
// Step 1: Get tenant API key
var tenantDetails = await _tenantDetailsRepository.GetAll()
.FirstOrDefaultAsync(t => t.TenantId == tenantId);
if (tenantDetails == null || string.IsNullOrEmpty(tenantDetails.APIKey))
{
output.Errors.Add("No se encontró la configuración del tenant o API key");
return output;
}
var apiKey = tenantDetails.APIKey;
// Step 2: Get all local networks with organization info
var localNetworks = await _networkRepository.GetAll()
.Include(n => n.Organization)
.Where(n => n.TenantId == tenantId && !n.IsDeleted)
.ToListAsync();
output.TotalNetworksLocal = localNetworks.Count;
if (!localNetworks.Any())
{
output.Errors.Add("No se encontraron redes locales para sincronizar");
return output;
}
// Step 3: Group networks by organization
var networksByOrg = localNetworks
.Where(n => n.Organization != null && !string.IsNullOrEmpty(n.Organization.MerakiId))
.GroupBy(n => n.Organization.MerakiId)
.ToList();
// Step 4: Process each organization
foreach (var orgGroup in networksByOrg)
{
var organizationId = orgGroup.Key;
try
{
// Get all networks from Meraki for this organization
var merakiNetworks = await _merakiService.GetOrganizationNetworks(
organizationId,
apiKey);
output.TotalNetworksInMeraki += merakiNetworks?.Count ?? 0;
if (merakiNetworks == null || !merakiNetworks.Any())
{
output.Errors.Add($"No se encontraron redes en Meraki para la organización {organizationId}");
continue;
}
// Get all devices for this organization (for AP count)
List<Meraki.Dto.MerakiNetworkDevice> allOrgDevices = null;
try
{
allOrgDevices = await _merakiService.GetOrganizationDevices(
organizationId,
apiKey,
type: "wireless"); // Filter by wireless devices (APs)
}
catch (Exception ex)
{
Logger.Warn($"No se pudieron obtener dispositivos de organización {organizationId}: {ex.Message}");
allOrgDevices = new List<Meraki.Dto.MerakiNetworkDevice>();
}
// Process each local network in this organization
foreach (var localNetwork in orgGroup)
{
try
{
// Find corresponding Meraki network by MerakiId
var merakiNetwork = merakiNetworks.FirstOrDefault(m => m.Id == localNetwork.MerakiId);
if (merakiNetwork == null)
{
output.Errors.Add($"Red local '{localNetwork.Name}' (ID: {localNetwork.MerakiId}) no encontrada en Meraki");
continue;
}
// Get Meraki APs for this specific network
var merakiAPsForNetwork = allOrgDevices?
.Where(d => d.networkId == localNetwork.MerakiId &&
!string.IsNullOrEmpty(d.model) &&
d.model.StartsWith("MR", StringComparison.OrdinalIgnoreCase))
.ToList() ?? new List<Meraki.Dto.MerakiNetworkDevice>();
int merakiAPCount = merakiAPsForNetwork.Count;
// Get local APs for this network from database
var localAPs = await _accessPointRepository
.GetAllReadonly()
.Where(ap => ap.NetworkId == localNetwork.Id && !ap.IsDeleted)
.ToListAsync();
int localAPCount = localAPs.Count;
// Calculate missing APs (in Meraki but not in local DB, matched by Serial)
int missingAPCount = merakiAPsForNetwork
.Count(merakiAP => !localAPs.Any(localAP => localAP.Serial == merakiAP.serial));
output.TotalAPsInMeraki += merakiAPCount;
output.TotalAPsLocal += localAPCount;
// Check if name is different
bool nameChanged = !string.Equals(localNetwork.Name, merakiNetwork.Name, StringComparison.Ordinal);
bool apsAreSynced = (missingAPCount == 0);
bool networkHasDiff = nameChanged || !apsAreSynced;
// Apply OnlyShowDiff filter: if enabled, only include networks with differences
if (!input.OnlyShowDiff || networkHasDiff)
{
var change = new NetworkChangeDto
{
NetworkId = localNetwork.Id,
MerakiId = localNetwork.MerakiId,
OldName = localNetwork.Name,
NewName = merakiNetwork.Name,
OrganizationName = localNetwork.Organization.Name,
LocalAPCount = localAPCount,
MerakiAPCount = merakiAPCount,
MissingAPCount = missingAPCount,
APsSynchronized = apsAreSynced,
NetworkHasDiff = networkHasDiff
};
output.Changes.Add(change);
// Count networks by type
if (nameChanged)
{
output.NetworksWithNameChanges++;
}
else
{
output.NetworksUnchanged++;
}
// If Process mode is enabled and name changed, apply the change
if (input.Process && nameChanged)
{
localNetwork.Name = merakiNetwork.Name;
await _networkRepository.UpdateAsync(localNetwork);
}
// If ProcessAPs is also enabled, sync APs
if (input.Process && input.ProcessAPs && !apsAreSynced)
{
try
{
// Find APs that are in Meraki but not in local DB (match by Serial)
var missingAPs = merakiAPsForNetwork
.Where(merakiAP => !localAPs.Any(localAP => localAP.Serial == merakiAP.serial))
.ToList();
if (missingAPs.Any())
{
// Create new SplashAccessPoint entities for missing APs
foreach (var merakiAP in missingAPs)
{
var newAccessPoint = new SplashAccessPoint
{
Serial = merakiAP.serial,
Mac = merakiAP.mac,
Name = merakiAP.name,
Model = merakiAP.model,
Latitude = merakiAP.lat?.ToString(),
Longitude = merakiAP.lng?.ToString(),
NetworkId = localNetwork.Id, // FK to local network
LanIP = merakiAP.lanIP,
CreationTime = Clock.Now
};
await _accessPointRepository.InsertAsync(newAccessPoint);
output.SynchronizedAPsCount++;
}
// Save the new APs to database
await CurrentUnitOfWork.SaveChangesAsync();
// Update the change status - APs are now synchronized
change.APsSynchronized = true;
change.NetworkHasDiff = nameChanged; // Only name diff remains (if any)
}
}
catch (Exception ex)
{
output.Errors.Add($"Error sincronizando APs de red '{localNetwork.Name}': {ex.Message}");
Logger.Error($"Error syncing APs for network {localNetwork.Id}", ex);
}
}
}
else
{
// Network has no differences, only count it
output.NetworksUnchanged++;
}
}
catch (Exception ex)
{
var networkName = localNetwork?.Name ?? "Unknown";
output.Errors.Add($"Error procesando red '{networkName}': {ex.Message}");
Logger.Error($"Error syncing network {localNetwork?.Id}", ex);
}
}
}
catch (Exception ex)
{
output.Errors.Add($"Error procesando organización {organizationId}: {ex.Message}");
Logger.Error($"Error syncing organization {organizationId}", ex);
}
}
// Save changes if Process mode was enabled
if (input.Process && output.NetworksWithNameChanges > 0)
{
await CurrentUnitOfWork.SaveChangesAsync();
}
// Calculate total missing APs across all changes
output.MissingAPsCount = output.Changes.Sum(c => c.MissingAPCount);
return output;
}
catch (Exception ex)
{
output.Errors.Add($"Error general: {ex.Message}");
Logger.Error("Error in SyncNetworkNamesAsync", ex);
return output;
}
}
}
}

2
src/SplashPage.Web.Host/appsettings.json
View File

@@ -2,7 +2,7 @@
"ConnectionStrings": {
//"Default": "Server=172.21.4.113;Database=SplashPageBase;User=Jordi;Password=SqlS3rv3r;Encrypt=True;TrustServerCertificate=True;",
//"Default": "Server=45.168.234.22;Port=5000;Database=SULTANES_db_Splash;Password=Bpusr001;User=root",
"Default": "User ID=mysql;Password=Bpusr001;Host=45.168.234.22;Port=5001;Database=lc_db_splash;Pooling=true;Minimum Pool Size=20;Maximum Pool Size=150;Connection Idle Lifetime=300;Connection Pruning Interval=5;Timeout=30;Command Timeout=360;"
"Default": "User ID=mysql;Password=Bpusr001;Host=45.168.234.22;Port=5001;Database=nazan_db_splash;Pooling=true;Minimum Pool Size=20;Maximum Pool Size=150;Connection Idle Lifetime=300;Connection Pruning Interval=5;Timeout=30;Command Timeout=360;"
//"Default": "User ID=mysql;Password=Bpusr001;Host=2.tcp.ngrok.io;Port=11925;Database=nazan_db_splash;Pooling=true;Command Timeout=360;"
},
"App": {

2
src/SplashPage.Web.Mvc/appsettings.json
View File

@@ -2,7 +2,7 @@
"ConnectionStrings": {
//"Default": "Server=172.21.4.113;Database=SplashPageBase;User=Jordi;Password=SqlS3rv3r;Encrypt=True;TrustServerCertificate=True;",
//"Default": "Server=45.168.234.22;Port=5000;Database=SULTANES_db_Splash;Password=Bpusr001;User=root",
"Default": "User ID=mysql;Password=Bpusr001;Host=45.168.234.22;Port=5001;Database=lc_db_splash;Pooling=true;Minimum Pool Size=20;Maximum Pool Size=150;Connection Idle Lifetime=300;Connection Pruning Interval=5;Timeout=30;Command Timeout=360;"
"Default": "User ID=mysql;Password=Bpusr001;Host=45.168.234.22;Port=5001;Database=nazan_db_splash;Pooling=true;Minimum Pool Size=20;Maximum Pool Size=150;Connection Idle Lifetime=300;Connection Pruning Interval=5;Timeout=30;Command Timeout=360;"
//"Default": "User ID=mysql;Password=Bpusr001;Host=2.tcp.ngrok.io;Port=11925;Database=nazan_db_splash;Pooling=true;Command Timeout=360;"
},
"Authentication": {