michele/sledgemapper
1
0
Fork 0
Code Issues 5 Pull requests Projects Releases 4 Wiki Activity

refactoring

Browse source
This commit is contained in:
Michele 2020-11-08 23:48:15 +00:00
parent 9c100531ef
commit 92f333a4c4
26 changed files with 860 additions and 491 deletions
Download patch file Download diff file Expand all files Collapse all files

117
Sledgemapper.Api/Handlers/NewTileHandler.cs
View file

@ -1,117 +0,0 @@
using MediatR;
using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.SignalR;
using SignalRChat.Hubs;
using Sledgemapper.Api.Data;
using Sledgemapper.Clients;
using Sledgemapper.Shared.Entities;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
namespace Sledgemapper.Api.Handlers
{
public abstract class BaseNotification : INotification
{
public double Timestamp { get; private set; }
public string SessionName { get; private set; }
public BaseNotification(string sessionName)
{
Timestamp = DateTimeOffset.Now.ToUnixTimeMilliseconds();
SessionName = sessionName;
}
}
public class NewTileNotification : BaseNotification
{
public Tile Tile { get; private set; }
public NewTileNotification(string sessionName, Tile tile) : base(sessionName)
{
Tile = tile;
}
}
public class NewOverlayNotification : BaseNotification
{
public Overlay Overlay { get; private set; }
public NewOverlayNotification(string sessionName, Overlay overlay) : base(sessionName)
{
Overlay = overlay;
}
}
public class SendNewTileMessage : INotificationHandler<NewTileNotification>
{
private readonly IHubContext<SledgemapperHub, ISledgemapperClient> _hub;
public SendNewTileMessage(IHubContext<SledgemapperHub, ISledgemapperClient> hub) => _hub = hub;
public async Task Handle(NewTileNotification notification, CancellationToken cancellationToken)
{
await _hub.Clients.Groups(notification.SessionName).NewTile(notification.Tile);
}
}
public class SaveNewTile : INotificationHandler<NewTileNotification>
{
private readonly MyDbContext _dbcontext;
public SaveNewTile(MyDbContext dbcontext) => _dbcontext = dbcontext;
public async Task Handle(NewTileNotification notification, CancellationToken cancellationToken)
{
var jsonString = JsonSerializer.Serialize<Tile>(notification.Tile);
_dbcontext.MapLogs.Add(new Sledgemapper.Api.Models.MapLog
{
Operation = "N",
SessionName = notification.SessionName,
Type = "T",
Timestamp = notification.Timestamp,
Object = jsonString
});
await _dbcontext.SaveChangesAsync();
}
}
public class SendNewOverlayMessage : INotificationHandler<NewOverlayNotification>
{
private readonly IHubContext<SledgemapperHub, ISledgemapperClient> _hub;
public SendNewOverlayMessage(IHubContext<SledgemapperHub, ISledgemapperClient> hub) => _hub = hub;
public async Task Handle(NewOverlayNotification notification, CancellationToken cancellationToken)
{
await _hub.Clients.Groups(notification.SessionName).NewOverlay(notification.Overlay);
}
}
public class SaveNewOverlay : INotificationHandler<NewOverlayNotification>
{
private readonly MyDbContext _dbcontext;
public SaveNewOverlay(MyDbContext dbcontext) => _dbcontext = dbcontext;
public async Task Handle(NewOverlayNotification notification, CancellationToken cancellationToken)
{
var jsonString = JsonSerializer.Serialize<Overlay>(notification.Overlay);
_dbcontext.MapLogs.Add(new Sledgemapper.Api.Models.MapLog
{
Operation = "N",
SessionName = notification.SessionName,
Type = "O",
Timestamp = notification.Timestamp,
Object = jsonString
});
await _dbcontext.SaveChangesAsync();
}
}
}

32
Sledgemapper.Api/Handlers/SaveDeleteOverlay.cs Normal file
View file

@ -0,0 +1,32 @@
using MediatR;
using Sledgemapper.Api.Data;
using Sledgemapper.Shared.Entities;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
namespace Sledgemapper.Api.Handlers
{
public class SaveDeleteOverlay : INotificationHandler<DeleteOverlayNotification>
{
private readonly MyDbContext _dbcontext;
public SaveDeleteOverlay(MyDbContext dbcontext) => _dbcontext = dbcontext;
public async Task Handle(DeleteOverlayNotification notification, CancellationToken cancellationToken)
{
var jsonString = JsonSerializer.Serialize<Overlay>(notification.Overlay);
_dbcontext.MapLogs.Add(new Sledgemapper.Api.Models.MapLog
{
Operation = "D",
SessionName = notification.SessionName,
Type = "O",
Timestamp = notification.Timestamp,
Object = jsonString
});
await _dbcontext.SaveChangesAsync();
}
}
}

31
Sledgemapper.Api/Handlers/SaveDeleteTile.cs Normal file
View file

@ -0,0 +1,31 @@
using MediatR;
using Sledgemapper.Api.Data;
using Sledgemapper.Shared.Entities;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
namespace Sledgemapper.Api.Handlers
{
public class SaveDeleteTile : INotificationHandler<DeleteTileNotification>
{
private readonly MyDbContext _dbcontext;
public SaveDeleteTile(MyDbContext dbcontext) => _dbcontext = dbcontext;
public async Task Handle(DeleteTileNotification notification, CancellationToken cancellationToken)
{
var jsonString = JsonSerializer.Serialize<Tile>(notification.Tile);
_dbcontext.MapLogs.Add(new Sledgemapper.Api.Models.MapLog
{
Operation = "D",
SessionName = notification.SessionName,
Type = "T",
Timestamp = notification.Timestamp,
Object = jsonString
});
await _dbcontext.SaveChangesAsync();
}
}
}

35
Sledgemapper.Api/Handlers/SaveDeleteWall.cs Normal file
View file

@ -0,0 +1,35 @@
using MediatR;
using Microsoft.AspNetCore.Http.Features;
using Sledgemapper.Api.Data;
using Sledgemapper.Shared.Entities;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
namespace Sledgemapper.Api.Handlers
{
public class SaveDeleteWall : INotificationHandler<DeleteWallNotification>
{
private readonly MyDbContext _dbcontext;
public SaveDeleteWall(MyDbContext dbcontext) => _dbcontext = dbcontext;
public async Task Handle(DeleteWallNotification notification, CancellationToken cancellationToken)
{
var jsonString = JsonSerializer.Serialize<Wall>(notification.Wall);
_dbcontext.MapLogs.Add(new Sledgemapper.Api.Models.MapLog
{
Operation = "D",
SessionName = notification.SessionName,
Type = "W",
Timestamp = notification.Timestamp,
Object = jsonString
});
await _dbcontext.SaveChangesAsync();
}
}
}

32
Sledgemapper.Api/Handlers/SaveNewOverlay.cs Normal file
View file

@ -0,0 +1,32 @@
using MediatR;
using Sledgemapper.Api.Data;
using Sledgemapper.Shared.Entities;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
namespace Sledgemapper.Api.Handlers
{
public class SaveNewOverlay : INotificationHandler<NewOverlayNotification>
{
private readonly MyDbContext _dbcontext;
public SaveNewOverlay(MyDbContext dbcontext) => _dbcontext = dbcontext;
public async Task Handle(NewOverlayNotification notification, CancellationToken cancellationToken)
{
var jsonString = JsonSerializer.Serialize<Overlay>(notification.Overlay);
_dbcontext.MapLogs.Add(new Sledgemapper.Api.Models.MapLog
{
Operation = "N",
SessionName = notification.SessionName,
Type = "O",
Timestamp = notification.Timestamp,
Object = jsonString
});
await _dbcontext.SaveChangesAsync();
}
}
}

31
Sledgemapper.Api/Handlers/SaveNewTile.cs Normal file
View file

@ -0,0 +1,31 @@
using MediatR;
using Sledgemapper.Api.Data;
using Sledgemapper.Shared.Entities;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
namespace Sledgemapper.Api.Handlers
{
public class SaveNewTile : INotificationHandler<NewTileNotification>
{
private readonly MyDbContext _dbcontext;
public SaveNewTile(MyDbContext dbcontext) => _dbcontext = dbcontext;
public async Task Handle(NewTileNotification notification, CancellationToken cancellationToken)
{
var jsonString = JsonSerializer.Serialize<Tile>(notification.Tile);
_dbcontext.MapLogs.Add(new Sledgemapper.Api.Models.MapLog
{
Operation = "N",
SessionName = notification.SessionName,
Type = "T",
Timestamp = notification.Timestamp,
Object = jsonString
});
await _dbcontext.SaveChangesAsync();
}
}
}

31
Sledgemapper.Api/Handlers/SaveNewWall.cs Normal file
View file

@ -0,0 +1,31 @@
using MediatR;
using Sledgemapper.Api.Data;
using Sledgemapper.Shared.Entities;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
namespace Sledgemapper.Api.Handlers
{
public class SaveNewWall : INotificationHandler<NewWallNotification>
{
private readonly MyDbContext _dbcontext;
public SaveNewWall(MyDbContext dbcontext) => _dbcontext = dbcontext;
public async Task Handle(NewWallNotification notification, CancellationToken cancellationToken)
{
var jsonString = JsonSerializer.Serialize<Wall>(notification.Wall);
_dbcontext.MapLogs.Add(new Sledgemapper.Api.Models.MapLog
{
Operation = "N",
SessionName = notification.SessionName,
Type = "W",
Timestamp = notification.Timestamp,
Object = jsonString
});
await _dbcontext.SaveChangesAsync();
}
}
}

21
Sledgemapper.Api/Handlers/SendDeleteOverlayMessage.cs Normal file
View file

@ -0,0 +1,21 @@
using MediatR;
using Microsoft.AspNetCore.SignalR;
using SignalRChat.Hubs;
using Sledgemapper.Clients;
using System.Threading;
using System.Threading.Tasks;
namespace Sledgemapper.Api.Handlers
{
public class SendDeleteOverlayMessage : INotificationHandler<DeleteOverlayNotification>
{
private readonly IHubContext<SledgemapperHub, ISledgemapperClient> _hub;
public SendDeleteOverlayMessage(IHubContext<SledgemapperHub, ISledgemapperClient> hub) => _hub = hub;
public async Task Handle(DeleteOverlayNotification notification, CancellationToken cancellationToken)
{
await _hub.Clients.Groups(notification.SessionName).DeleteOverlay(notification.Overlay);
}
}
}

21
Sledgemapper.Api/Handlers/SendDeleteTileMessage.cs Normal file
View file

@ -0,0 +1,21 @@
using MediatR;
using Microsoft.AspNetCore.SignalR;
using SignalRChat.Hubs;
using Sledgemapper.Clients;
using System.Threading;
using System.Threading.Tasks;
namespace Sledgemapper.Api.Handlers
{
public class SendDeleteTileMessage : INotificationHandler<DeleteTileNotification>
{
private readonly IHubContext<SledgemapperHub, ISledgemapperClient> _hub;
public SendDeleteTileMessage(IHubContext<SledgemapperHub, ISledgemapperClient> hub) => _hub = hub;
public async Task Handle(DeleteTileNotification notification, CancellationToken cancellationToken)
{
await _hub.Clients.Groups(notification.SessionName).DeleteTile(notification.Tile);
}
}
}

21
Sledgemapper.Api/Handlers/SendDeleteWallMessage.cs Normal file
View file

@ -0,0 +1,21 @@
using MediatR;
using Microsoft.AspNetCore.SignalR;
using SignalRChat.Hubs;
using Sledgemapper.Clients;
using System.Threading;
using System.Threading.Tasks;
namespace Sledgemapper.Api.Handlers
{
public class SendDeleteWallMessage : INotificationHandler<DeleteWallNotification>
{
private readonly IHubContext<SledgemapperHub, ISledgemapperClient> _hub;
public SendDeleteWallMessage(IHubContext<SledgemapperHub, ISledgemapperClient> hub) => _hub = hub;
public async Task Handle(DeleteWallNotification notification, CancellationToken cancellationToken)
{
await _hub.Clients.Groups(notification.SessionName).DeleteWall(notification.Wall);
}
}
}

21
Sledgemapper.Api/Handlers/SendNewOverlayMessage.cs Normal file
View file

@ -0,0 +1,21 @@
using MediatR;
using Microsoft.AspNetCore.SignalR;
using SignalRChat.Hubs;
using Sledgemapper.Clients;
using System.Threading;
using System.Threading.Tasks;
namespace Sledgemapper.Api.Handlers
{
public class SendNewOverlayMessage : INotificationHandler<NewOverlayNotification>
{
private readonly IHubContext<SledgemapperHub, ISledgemapperClient> _hub;
public SendNewOverlayMessage(IHubContext<SledgemapperHub, ISledgemapperClient> hub) => _hub = hub;
public async Task Handle(NewOverlayNotification notification, CancellationToken cancellationToken)
{
await _hub.Clients.Groups(notification.SessionName).NewOverlay(notification.Overlay);
}
}
}

21
Sledgemapper.Api/Handlers/SendNewTileMessage.cs Normal file
View file

@ -0,0 +1,21 @@
using MediatR;
using Microsoft.AspNetCore.SignalR;
using SignalRChat.Hubs;
using Sledgemapper.Clients;
using System.Threading;
using System.Threading.Tasks;
namespace Sledgemapper.Api.Handlers
{
public class SendNewTileMessage : INotificationHandler<NewTileNotification>
{
private readonly IHubContext<SledgemapperHub, ISledgemapperClient> _hub;
public SendNewTileMessage(IHubContext<SledgemapperHub, ISledgemapperClient> hub) => _hub = hub;
public async Task Handle(NewTileNotification notification, CancellationToken cancellationToken)
{
await _hub.Clients.Groups(notification.SessionName).NewTile(notification.Tile);
}
}
}

21
Sledgemapper.Api/Handlers/SendNewWallMessage.cs Normal file
View file

@ -0,0 +1,21 @@
using MediatR;
using Microsoft.AspNetCore.SignalR;
using SignalRChat.Hubs;
using Sledgemapper.Clients;
using System.Threading;
using System.Threading.Tasks;
namespace Sledgemapper.Api.Handlers
{
public class SendNewWallMessage : INotificationHandler<NewWallNotification>
{
private readonly IHubContext<SledgemapperHub, ISledgemapperClient> _hub;
public SendNewWallMessage(IHubContext<SledgemapperHub, ISledgemapperClient> hub) => _hub = hub;
public async Task Handle(NewWallNotification notification, CancellationToken cancellationToken)
{
await _hub.Clients.Groups(notification.SessionName).NewWall(notification.Wall);
}
}
}