public async Task TestConflictMustContainAtLeastTwoFeedbacks()
{
Authenticate(
new[] { new Claim(SecurityUtils.ACCOUNT_ID_CLAIM, 1.ToString()) },
Scopes.SCOPE_BOT_OWNER
);
var request = new CreateDashboardRequest
{
BotName = "asd",
DashboardName = "da",
Description = "ds",
Secret = "abc",
Feedbacks = new List <CreateBotRequestFeedback>
{
new CreateBotRequestFeedback {
Id = -1, Name = "tp"
},
new CreateBotRequestFeedback {
Id = -2, Name = "fp"
},
},
ConflictExceptions = new List <CreateBotRequestExceptions>
{
new CreateBotRequestExceptions {
Id = -1, BotResponseConflictFeedbacks = new List <int> {
}
},
}
};
var response = await Client.PostAsync("/Admin/RegisterDashboard", request);
await response.AssertError(HttpStatusCode.BadRequest, "Conflicts must contain at least two feedback types");
}
public async Task TestBotCreateDuplicateFeedbackIds()
{
Authenticate(
new[] { new Claim(SecurityUtils.ACCOUNT_ID_CLAIM, 1.ToString()) },
Scopes.SCOPE_BOT_OWNER
);
var request = new CreateDashboardRequest
{
BotName = "asd",
DashboardName = "da",
Description = "ds",
Secret = "abc",
Feedbacks = new List <CreateBotRequestFeedback>
{
new CreateBotRequestFeedback {
Id = -1, Name = "tp"
},
new CreateBotRequestFeedback {
Id = -1, Name = "fp"
},
}
};
var response = await Client.PostAsync("/Admin/RegisterDashboard", request);
await response.AssertError(HttpStatusCode.BadRequest, "Duplicate feedback ids");
}
public CreateDashboardResponse Handle(CreateDashboardRequest request)
{
var response = new CreateDashboardResponse();
response.Errors = Validate(request);
if (response.HasErrors)
{
return(response);
}
try
{
var dateNow = DateTime.Now;
int dashId = _dashRepository.CreateAndGetId(new DashBoard
{
Name = request.DashName,
DateModified = dateNow,
DateCreated = dateNow,
UserId = request.UserId
});
response.Dashboard = _dashRepository.Get(dashId);
}
catch (Exception ex)
{
//response.Errors.Add(new ErrorStatus("BAD_REQUEST"));
response.Errors.Add(new ErrorStatus(ex.Message));
}
return(response);
}
public HttpResponseMessage Create(string ticket, string dashName)
{
var securityProvider = new SecurityProvider(_connectionString);
var sessionInfo = securityProvider.GetSessionInfo(ticket);
if (sessionInfo == null)
{
return(Request.CreateResponse(HttpStatusCode.Unauthorized));
}
var deleteRequest = new CreateDashboardRequest
{
DashName = dashName,
UserId = sessionInfo.User.Id
};
var handler = new CreateDashboardHandler(_connectionString);
var response = handler.Handle(deleteRequest);
var statusCode = ResolveStatusCode(response);
return(Request.CreateResponse(statusCode, response));
}
public HttpResponseMessage Create(User user, string inviteCode) //done
{
var handler = new CreateUserHandler(_connectionString);
var response = handler.Handle(new CreateUserRequest
{
Email = user.Email,
Password = user.Password,
Username = user.Name,
InvitationCode = inviteCode
});
var createDashRequest = new CreateDashboardRequest
{
DashName = "Hello_DashBoardify",
UserId = response.UserId
};
var createDashHandler = new CreateDashboardHandler(_connectionString);
var createResponse = createDashHandler.Handle(createDashRequest);
if (createResponse.HasErrors || response.HasErrors)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, response));
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
public async Task <CreateDashboardResponse> CreateAsync(CreateDashboardRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var response = await ExecutePostRequestAsync <CreateDashboardResponse, CreateDashboardRequest>("/api/dashboards/db", null, request, _authentication);
return(response);
}
public async Task TestFeedbackPresentTwoConflictsValid2()
{
Authenticate(
new[] { new Claim(SecurityUtils.ACCOUNT_ID_CLAIM, 1.ToString()) },
Scopes.SCOPE_BOT_OWNER
);
var request = new CreateDashboardRequest
{
BotName = "asd",
DashboardName = "da",
Description = "ds",
Secret = "abc",
Feedbacks = new List <CreateBotRequestFeedback>
{
new CreateBotRequestFeedback {
Id = -1, Name = "tp"
},
new CreateBotRequestFeedback {
Id = -2, Name = "fp"
},
new CreateBotRequestFeedback {
Id = -3, Name = "nc"
},
new CreateBotRequestFeedback {
Id = -4, Name = "sk"
},
},
ConflictExceptions = new List <CreateBotRequestExceptions>
{
new CreateBotRequestExceptions {
Id = -1, BotResponseConflictFeedbacks = new List <int> {
-1, -2
}
},
new CreateBotRequestExceptions {
Id = -2, BotResponseConflictFeedbacks = new List <int> {
-2, -3
}
},
new CreateBotRequestExceptions {
Id = -3, BotResponseConflictFeedbacks = new List <int> {
-2, -4
}
}
}
};
var response = await Client.PostAsync("/Admin/RegisterDashboard", request);
await response.AssertSuccess();
}
public CreateDashboardResponse Create(CreateDashboardRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var task = Task.Run(() => CreateAsync(request));
task.Wait();
return(task.Result);
}
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));
}
public virtual async Task <ActionResult <DashboardDto> > Create([FromBody] CreateDashboardRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var dto = await _dashboardsService.CreateDashboardAsync(request);
if (dto == null)
{
return(StatusCode(500));
}
return(Ok(dto));
}
public async Task TestCreateBot()
{
Authenticate(
new[] { new Claim(SecurityUtils.ACCOUNT_ID_CLAIM, 1.ToString()) },
Scopes.SCOPE_BOT_OWNER
);
var request = new CreateDashboardRequest
{
BotName = "asd",
DashboardName = "da",
Description = "ds",
Secret = "abc",
Feedbacks = new List <CreateBotRequestFeedback>
{
new CreateBotRequestFeedback {
Id = -1, Name = "tp"
},
new CreateBotRequestFeedback {
Id = -2, Name = "fp"
},
},
ConflictExceptions = new List <CreateBotRequestExceptions>
{
new CreateBotRequestExceptions {
Id = -1, BotResponseConflictFeedbacks = new List <int> {
-1, -2
}
}
}
};
var response = await Client.PostAsync("/Admin/RegisterDashboard", request);
await response.AssertSuccess();
WithDatabase(dbContext =>
{
var tpFeedback = dbContext.Feedbacks.FirstOrDefault(f => f.Name == "tp");
var fpFeedback = dbContext.Feedbacks.FirstOrDefault(f => f.Name == "fp");
Assert.AreEqual(2, dbContext.ConflictExceptionFeedbacks.Count());
Assert.NotNull(dbContext.ConflictExceptionFeedbacks.FirstOrDefault(a => a.FeedbackId == tpFeedback.Id));
Assert.NotNull(dbContext.ConflictExceptionFeedbacks.FirstOrDefault(a => a.FeedbackId == fpFeedback.Id));
});
}
public async Task TestInvalidConflictFeedback2()
{
Authenticate(
new[] { new Claim(SecurityUtils.ACCOUNT_ID_CLAIM, 1.ToString()) },
Scopes.SCOPE_BOT_OWNER
);
var request = new CreateDashboardRequest
{
BotName = "asd",
DashboardName = "da",
Description = "ds",
Secret = "abc",
Feedbacks = new List <CreateBotRequestFeedback>
{
new CreateBotRequestFeedback {
Id = -1, Name = "tp"
},
new CreateBotRequestFeedback {
Id = -2, Name = "fp"
},
new CreateBotRequestFeedback {
Id = -3, Name = "nc"
},
},
ConflictExceptions = new List <CreateBotRequestExceptions>
{
new CreateBotRequestExceptions {
Id = -1, BotResponseConflictFeedbacks = new List <int> {
-1, -2
}
},
new CreateBotRequestExceptions {
Id = -2, BotResponseConflictFeedbacks = new List <int> {
-1, -2, -3
}
}
}
};
var response = await Client.PostAsync("/Admin/RegisterDashboard", request);
await response.AssertError(HttpStatusCode.BadRequest, "A pair of feedback ids cannot appear in two different conflicts");
}
public List <ErrorStatus> Validate(CreateDashboardRequest request)
{
var errors = new List <ErrorStatus>();
if (string.IsNullOrEmpty(request.DashName))
{
errors.Add(new ErrorStatus("DASH_NAME_NOT_DEFINED"));
return(errors);
}
if (request.DashName.Length > 254)
{
errors.Add(new ErrorStatus("NAME_TOO_LONG"));
return(errors);
}
return(errors);
}
public async Task <DashboardDto> CreateDashboardAsync(CreateDashboardRequest request)
{
var entity = _mapper.Map <CreateDashboardRequest, Dashboard>(request);
entity.CreatedAt = DateTime.UtcNow;
entity = await _uow.DashboardsRepository.CreateAsync(entity);
var result = await _uow.SaveAsync();
if (!result)
{
return(null);
}
if (entity == null)
{
return(null);
}
var dto = _mapper.Map <Dashboard, DashboardDto>(entity);
return(dto);
}
protected override void ProcessRecord()
{
base.ProcessRecord();
CreateDashboardRequest request;
try
{
request = new CreateDashboardRequest
{
CreateDashboardDetails = CreateDashboardDetails,
OpcRetryToken = OpcRetryToken,
OpcRequestId = OpcRequestId,
OpcCrossRegion = OpcCrossRegion
};
response = client.CreateDashboard(request).GetAwaiter().GetResult();
WriteOutput(response, response.Dashboard);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
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);
}
);
}
