public IActionResult RegisterDashboard([FromBody] CreateDashboardRequest request)
{
if (string.IsNullOrWhiteSpace(request.BotName))
{
return(BadRequest(new ErrorResponse("Name is required")));
}
if (string.IsNullOrWhiteSpace(request.Description))
{
return(BadRequest(new ErrorResponse("Description is required")));
}
if (string.IsNullOrWhiteSpace(request.Secret))
{
return(BadRequest(new ErrorResponse("Secret is required")));
}
if (_dbContext.Dashboards.Any(b => b.DashboardName == request.DashboardName))
{
return(BadRequest(new ErrorResponse($"Dashboard with name '{request.DashboardName}' already exists")));
}
var userId = User.GetUserId();
if (!userId.HasValue)
{
throw new HttpStatusException(HttpStatusCode.Unauthorized);
}
var dashboard = new DbDashboard
{
Scopes = new List <DbDashboardScope>(),
Feedbacks = new List <DbFeedback>(),
ConflictExceptions = new List <DbConflictException>()
};
FillDashboardDetails(dashboard, request);
if (request.OwnerAccountId.HasValue && User.HasClaim(Scopes.SCOPE_ADMIN))
{
dashboard.OwnerAccountId = request.OwnerAccountId.Value;
}
_dbContext.Dashboards.Add(dashboard);
_dbContext.DashboardScopes.Add(new DbDashboardScope
{
Dashboard = dashboard,
ScopeName = Scopes.SCOPE_BOT
});
_dbContext.SaveChanges();
return(Json(dashboard.Id));
}
private void FillDashboardDetails(DbDashboard existingDashboard, CreateDashboardRequest request)
{
if (request.Feedbacks == null)
{
request.Feedbacks = new List <CreateBotRequestFeedback>();
}
if (request.Feedbacks.GroupBy(f => f.Id).Any(g => g.Count() > 1))
{
throw new HttpStatusException(HttpStatusCode.BadRequest, "Duplicate feedback ids");
}
if (request.ConflictExceptions == null)
{
request.ConflictExceptions = new List <CreateBotRequestExceptions>();
}
if (request.ConflictExceptions.GroupBy(f => f.Id).Any(g => g.Count() > 1))
{
throw new HttpStatusException(HttpStatusCode.BadRequest, "Duplicate conflict exception ids");
}
ConflictHelper.AssertUniqueConflictFeedbacks(request.ConflictExceptions.Select(c => c.BotResponseConflictFeedbacks));
existingDashboard.BotName = request.BotName;
existingDashboard.DashboardName = request.DashboardName;
existingDashboard.Description = request.Description;
if (!string.IsNullOrWhiteSpace(request.Secret))
{
existingDashboard.Secret = BCrypt.Net.BCrypt.HashPassword(request.Secret);
}
if (request.OwnerAccountId.HasValue && User.HasClaim(Scopes.SCOPE_ADMIN))
{
existingDashboard.OwnerAccountId = request.OwnerAccountId.Value;
}
existingDashboard.FavIcon = request.FavIcon;
existingDashboard.Homepage = request.Homepage;
existingDashboard.LogoUrl = request.LogoUrl;
existingDashboard.TabTitle = request.TabTitle;
existingDashboard.RequiredFeedback = request.RequiredFeedback;
existingDashboard.RequiredFeedbackConflicted = request.RequiredFeedbackConflicted;
var createdFeedbacks = new Dictionary <int, DbFeedback>();
CollectionUpdater.UpdateCollection(
existingDashboard.Feedbacks.ToDictionary(f => f.Id, f => f),
request.Feedbacks.ToDictionary(f => f.Id, f => f),
newFeedback =>
{
var dbFeedbackType = new DbFeedback
{
Dashboard = existingDashboard,
Name = newFeedback.Name,
Colour = newFeedback.Colour,
Icon = newFeedback.Icon,
IsActionable = newFeedback.IsActionable,
IsEnabled = newFeedback.IsEnabled
};
existingDashboard.Feedbacks.Add(dbFeedbackType);
_dbContext.Feedbacks.Add(dbFeedbackType);
createdFeedbacks.Add(newFeedback.Id, dbFeedbackType);
},
(existingFeedback, newFeedback) =>
{
existingFeedback.Name = newFeedback.Name;
existingFeedback.Colour = newFeedback.Colour;
existingFeedback.Icon = newFeedback.Icon;
existingFeedback.IsActionable = newFeedback.IsActionable;
existingFeedback.IsEnabled = newFeedback.IsEnabled;
},
existingFeedback => { }
);
if (existingDashboard.Feedbacks.GroupBy(f => f.Name, StringComparer.OrdinalIgnoreCase).Any(g => g.Count() > 1))
{
throw new HttpStatusException(HttpStatusCode.BadRequest, "Feedback names must be unique");
}
CollectionUpdater.UpdateCollection(
existingDashboard.ConflictExceptions.ToDictionary(ce => ce.Id, ce => ce),
request.ConflictExceptions.ToDictionary(ce => ce.Id, ce => ce),
newConflict =>
{
var dbConflictException = new DbConflictException
{
Dashboard = existingDashboard,
IsConflict = newConflict.IsConflict,
RequiresAdmin = newConflict.RequiresAdmin,
RequiredFeedback = newConflict.RequiredFeedback
};
foreach (var conflictFeedbackId in newConflict.BotResponseConflictFeedbacks)
{
var newConflictException = new DbConflictExceptionFeedback
{
ConflictException = dbConflictException
};
if (conflictFeedbackId < 0)
{
if (createdFeedbacks.ContainsKey(conflictFeedbackId))
{
newConflictException.Feedback = createdFeedbacks[conflictFeedbackId];
}
else
{
throw new HttpStatusException(HttpStatusCode.BadRequest, "Invalid FeedbackId for conflict");
}
}
else
{
newConflictException.FeedbackId = conflictFeedbackId;
}
_dbContext.ConflictExceptionFeedbacks.Add(newConflictException);
}
existingDashboard.ConflictExceptions.Add(dbConflictException);
_dbContext.ConflictExceptions.Add(dbConflictException);
},
(existingConflict, newConflict) =>
{
existingConflict.IsConflict = newConflict.IsConflict;
existingConflict.RequiresAdmin = newConflict.RequiresAdmin;
existingConflict.RequiredFeedback = newConflict.RequiredFeedback;
CollectionUpdater.UpdateCollection(
existingConflict.ConflictExceptionFeedbacks.ToDictionary(d => d.FeedbackId, d => d),
newConflict.BotResponseConflictFeedbacks.ToDictionary(d => d, d => d),
newConflictFeedbackId =>
{
var newConflictException = new DbConflictExceptionFeedback
{
ConflictException = existingConflict
};
if (newConflictFeedbackId < 0)
{
if (createdFeedbacks.ContainsKey(newConflictFeedbackId))
{
newConflictException.Feedback = createdFeedbacks[newConflictFeedbackId];
}
else
{
throw new HttpStatusException(HttpStatusCode.BadRequest, "Invalid FeedbackId for conflict");
}
}
else
{
newConflictException.FeedbackId = newConflictFeedbackId;
}
_dbContext.ConflictExceptionFeedbacks.Add(newConflictException);
},
(existingConflictFeedback, newConflictFeedback) => { },
existingConflictFeedback =>
{
_dbContext.ConflictExceptionFeedbacks.Remove(existingConflictFeedback);
}
);
},
existingConflict =>
{
_dbContext.ConflictExceptions.Remove(existingConflict);
}
);
}
