public async Task GetById_ShouldSuccess()
{
var client = this.factory.CreateClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"Bearer",
await AuthenticationUtilities.GetTestUserAccessTokenAsync(client));
MessengerContext context = this.factory.Server.Host.Services.GetService(typeof(MessengerContext))
as MessengerContext;
await context.Users.AddRangeAsync(this.GenerateUsers(5));
await context.SaveChangesAsync();
var dbUser = await context.Users.Skip(2).FirstAsync();
var response = await client.GetAsync($"/api/users/{dbUser.Id}");
response.EnsureSuccessStatusCode();
var user = response.Content.ReadAsAsync(typeof(UserViewModel)).Result as UserViewModel;
Assert.NotNull(user);
Assert.Equal(dbUser.UserName, user.UserName);
}
public async Task PutUpdate_ShouldSuccess()
{
var client = this.factory.CreateClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"Bearer",
await AuthenticationUtilities.GetTestUserAccessTokenAsync(client));
MessengerContext context = this.factory.Server.Host.Services.GetService(typeof(MessengerContext))
as MessengerContext;
this.SeedDataForMessagesTesting(context);
User testUser = await context.Users.FirstAsync();
Message message = await context.Messages.Skip(1).FirstAsync();
string newContent = "new content";
var requestBody = new EditMessageViewModel {
MessageId = message.MessageId, Content = newContent
};
var requestContent = new StringContent(JsonConvert.SerializeObject(requestBody), Encoding.UTF8, "application/json");
var response = await client.PutAsync($"/api/messages/{message.MessageId}", requestContent);
response.EnsureSuccessStatusCode();
Message updated = await context.Messages.SingleAsync(x => x.MessageId == message.MessageId);
Assert.Equal(newContent, updated.Content);
}
public async Task GetUserNameContains_ShouldSuccess()
{
var client = this.factory.CreateClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"Bearer",
await AuthenticationUtilities.GetTestUserAccessTokenAsync(client));
MessengerContext context = this.factory.Server.Host.Services.GetService(typeof(MessengerContext))
as MessengerContext;
UserManager <User> userManager = this.factory.Server.Host.Services.GetService(typeof(UserManager <User>))
as UserManager <User>;
foreach (var item in this.GenerateUsers(5))
{
await userManager.CreateAsync(item);
}
var dbUser = await context.Users.Skip(2).FirstAsync();
var searchString = dbUser.UserName.Substring(0, 2);
var response = await client.GetAsync($"/api/users/UserNameContains/{searchString}");
response.EnsureSuccessStatusCode();
var users = response.Content.ReadAsAsync(typeof(IEnumerable <UserViewModel>)).Result as IEnumerable <UserViewModel>;
Assert.True(users.Any(x => x.UserName == dbUser.UserName));
}
public async Task Post_ShouldSuccess()
{
var client = this.factory.CreateClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"Bearer",
await AuthenticationUtilities.GetTestUserAccessTokenAsync(client));
MessengerContext context = this.factory.Server.Host.Services.GetService(typeof(MessengerContext))
as MessengerContext;
User user = this.GenerateUsers(1).Single();
var requestBody = new UserCredentialsViewModel {
Password = "******", UserName = user.UserName, Name = user.Name
};
var requestContent = new StringContent(JsonConvert.SerializeObject(requestBody), Encoding.UTF8, "application/json");
var response = await client.PostAsync($"/api/users", requestContent);
response.EnsureSuccessStatusCode();
UserManager <User> userManager = this.factory.Server.Host.Services.GetService(typeof(UserManager <User>))
as UserManager <User>;
var insertedUser = await userManager.FindByNameAsync(user.UserName);
Assert.NotNull(insertedUser);
}
public async Task Delete_ShouldSuccess()
{
var client = this.factory.CreateClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"Bearer",
await AuthenticationUtilities.GetTestUserAccessTokenAsync(client));
MessengerContext context = this.factory.Server.Host.Services.GetService(typeof(MessengerContext))
as MessengerContext;
this.SeedDataForMessagesTesting(context);
User testUser = await context.Users.FirstAsync();
Message message = await context.Messages.Skip(1).FirstAsync();
int previousCount = await context.Messages.CountAsync();
var response = await client.DeleteAsync($"/api/messages/{message.MessageId}");
response.EnsureSuccessStatusCode();
int currentCount = await context.Messages.CountAsync();
Assert.NotEqual(previousCount, currentCount);
Assert.Equal(previousCount, currentCount + 1);
Assert.False(await context.Messages.AnyAsync(x => x.MessageId == message.MessageId));
}
public async Task GetByConversation_ShouldSuccess()
{
var client = this.factory.CreateClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"Bearer",
await AuthenticationUtilities.GetTestUserAccessTokenAsync(client));
MessengerContext context = this.factory.Server.Host.Services.GetService(typeof(MessengerContext))
as MessengerContext;
this.SeedDataForMessagesTesting(context);
User testUser = await context.Users.FirstAsync();
Conversation testConversation = await context.Conversations.FirstAsync();
var response = await client.GetAsync($"/api/messages/Conversation/{testConversation.ConversationId}");
response.EnsureSuccessStatusCode();
var messages = response.Content.ReadAsAsync(typeof(IEnumerable <EditMessageViewModel>)).Result as IEnumerable <EditMessageViewModel>;
int messagesCount = await context.Messages.CountAsync(x => x.OwnerId == testUser.Id &&
x.Conversation.ConversationId == testConversation.ConversationId);
Assert.NotNull(messages);
Assert.Equal(messagesCount, messages.Count());
}
public async Task GetById_ShouldSuccess()
{
var client = this.factory.CreateClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"Bearer",
await AuthenticationUtilities.GetTestUserAccessTokenAsync(client));
MessengerContext context = this.factory.Server.Host.Services.GetService(typeof(MessengerContext))
as MessengerContext;
this.SeedDataForMessagesTesting(context);
User testUser = await context.Users.FirstAsync();
Message message = await context.Messages.Skip(1).FirstAsync();
var response = await client.GetAsync($"/api/messages/{message.MessageId}");
response.EnsureSuccessStatusCode();
var responseMessage = response.Content.ReadAsAsync(typeof(EditMessageViewModel)).Result as EditMessageViewModel;
Assert.NotNull(responseMessage);
Assert.Equal(message.Content, message.Content);
}
public async Task Delete_ShouldSuccess()
{
var client = this.factory.CreateClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"Bearer",
await AuthenticationUtilities.GetTestUserAccessTokenAsync(client));
MessengerContext context = this.factory.Server.Host.Services.GetService(typeof(MessengerContext))
as MessengerContext;
await context.Users.AddRangeAsync(this.GenerateUsers(5));
await context.SaveChangesAsync();
var dbUser = await context.Users.Skip(2).FirstAsync();
int previousCount = await context.Users.CountAsync();
var response = await client.DeleteAsync($"/api/users/{dbUser.Id}");
response.EnsureSuccessStatusCode();
int currentCount = await context.Users.CountAsync();
Assert.NotEqual(previousCount, currentCount);
Assert.Equal(previousCount, currentCount + 1);
Assert.False(await context.Users.AnyAsync(x => x.Id == dbUser.Id));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
services.AddAuthentication(x =>
{
x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(jwt =>
{
jwt.TokenValidationParameters = new Microsoft.IdentityModel.Tokens.TokenValidationParameters()
{
ValidateAudience = false,
ValidateIssuer = false,
IssuerSigningKey = AuthenticationUtilities.GetIssuerKey()
};
});
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
var contextInfo = new ContextInfo
{
ConnectionString = Configuration["StorageConnectionString"]
};
var contextProvider = new ContextProvider(contextInfo);
ContextProvider.Instance = contextProvider;
}
public async Task <IActionResult> AddUserToChat(string userUUID, string chatUUID, CancellationToken ct = default)
{
if (!AuthenticationUtilities.IsAllowedChat(User))
{
return(BadRequest("User has been banned from Chat"));
}
return(Ok(await _chatService.AddUserToChatAsync(userUUID, chatUUID, ct)));
}
public async Task <IActionResult> GetComment(int commentId, CancellationToken ct = default)
{
if (!AuthenticationUtilities.IsAllowedFeed(User))
{
return(BadRequest("User has been banned from Feed"));
}
return(Ok(await _feedService.GetCommentByIdAsync(commentId, ct)));
}
public async Task <IActionResult> GetMyDTOPosts(string uuid = "", CancellationToken ct = default)
{
if (!AuthenticationUtilities.IsAllowedFeed(User))
{
return(BadRequest("User has been banned from Feed"));
}
return(Ok(await _feedService.GetAllDTOPostsForUserAsync(!string.IsNullOrEmpty(uuid) ? uuid : AuthenticationUtilities.GetUUIDFromIdentity(User), ct)));
}
public async Task <IActionResult> CreateNewAditLog([FromBody] AditLog aditLog, CancellationToken ct = default)
{
if (!AuthenticationUtilities.IsAllowedFeed(User))
{
return(BadRequest("User has been banned from Feed"));
}
return(Ok(await _feedService.UploadNewAditLogAsync(aditLog, ct)));
}
public async Task <IActionResult> GetAditLogsAsync(int teamId = 0, CancellationToken ct = default)
{
if (!AuthenticationUtilities.IsAllowedFeed(User))
{
return(BadRequest("User has been banned from Feed"));
}
return(Ok(await _feedService.GetAllAditLogsAsync(teamId, ct)));
}
public async Task <IActionResult> GetMessageById(string messageUUID, CancellationToken ct = default)
{
if (!AuthenticationUtilities.IsAllowedChat(User))
{
return(BadRequest("User has been banned from Chat"));
}
return(Ok(await _chatService.GetMessageByIdAsync(messageUUID, ct)));
}
public async Task <IActionResult> GetMessagesForChat(string chatUUID, long startfrom, int limit = 20, CancellationToken ct = default)
{
if (!AuthenticationUtilities.IsAllowedChat(User))
{
return(BadRequest("User has been banned from Chat"));
}
return(Ok(await _chatService.GetMessagesForChatAsync(chatUUID, startfrom, limit, ct)));
}
public async Task <IActionResult> UpdateDetailsForUser(string uuid, [FromBody] UserDetails details, CancellationToken ct = default)
{
if (!AuthenticationUtilities.IsSameUserOrPrivileged(User, uuid))
{
return(Unauthorized("You do not have access to this endpoint"));
}
return(Ok(await _userRepository.UpdateUserDetailsAsync(uuid, details, ct)));
}
public async Task <IActionResult> ReportUser([FromBody] ChatMessageReport report, CancellationToken ct = default)
{
if (!AuthenticationUtilities.IsAllowedChat(User))
{
return(BadRequest("User has been banned from Chat"));
}
await _chatService.ReportMessageAsync(report, ct);
return(Ok());
}
public async Task <IActionResult> BotMessage([FromBody] ChatBotRequest request, CancellationToken ct = default)
{
if (!AuthenticationUtilities.IsAllowedChat(User))
{
return(BadRequest("User has been banned from Chat"));
}
string uuid = AuthenticationUtilities.GetUUIDFromIdentity(User);
return(Ok(await _chatBot.GetResponseForCommand(request.input, uuid, request.version)));
}
public async Task <IActionResult> ReportUser([FromBody] FeedReport report, CancellationToken ct = default)
{
if (!AuthenticationUtilities.IsAllowedFeed(User))
{
return(BadRequest("User has been banned from Feed"));
}
await _feedService.ReportPostAsync(report, ct);
return(Ok());
}
public async Task <IActionResult> MarkChatAsRead(string chatUUID, CancellationToken ct = default)
{
if (!AuthenticationUtilities.IsAllowedChat(User))
{
return(BadRequest("User has been banned from Chat"));
}
await _chatService.MarkChatAsReadAsync(AuthenticationUtilities.GetUUIDFromIdentity(User), chatUUID, ct);
return(Ok());
}
public async Task <IActionResult> AddMessageToChat(string chatUUID, [FromBody] ChatMessage message, CancellationToken ct = default)
{
if (!ModelState.IsValid)
{
return(BadRequest("Invalid message details"));
}
if (!AuthenticationUtilities.IsAllowedChat(User))
{
return(BadRequest("User has been banned from Chat"));
}
return(Ok(await _chatService.AddMessageToChatAsync(message, chatUUID, ct)));
}
public async Task <IActionResult> GetFeed(long startfrom, int limit = 10, int teamId = 0, CancellationToken ct = default)
{
if (!AuthenticationUtilities.IsAllowedFeed(User))
{
return(BadRequest("User has been banned from Feed"));
}
if (startfrom == 0)
{
startfrom = DateTime.UtcNow.Millisecond;
}
return(Ok(await _feedService.GetAllAsync(startfrom, teamId, limit, ct)));
}
public async Task <IActionResult> UploadChatAttachment(string chatUUID, CancellationToken ct = default)
{
if (HttpContext.Request.Form.Files.Count > 0)
{
return(Ok(await _chatService.UploadChatAttachmentAsync(HttpContext.Request.Form.Files[0], chatUUID, ct)));
}
if (!AuthenticationUtilities.IsAllowedChat(User))
{
return(BadRequest("User has been banned from Chat"));
}
return(BadRequest("No files specified"));
}
public async Task <IActionResult> CreateChat([FromBody] Chat chat, CancellationToken ct = default)
{
if (!ModelState.IsValid)
{
return(BadRequest("Invalid chat object"));
}
if (!AuthenticationUtilities.IsAllowedChat(User))
{
return(BadRequest("User has been banned from Chat"));
}
return(Ok(await _chatService.CreateNewChatAsync(chat, ct)));
}
public async Task <IActionResult> EditChat([FromBody] ChatEditDetails details, CancellationToken ct = default)
{
if (!ModelState.IsValid)
{
return(BadRequest("Invalid chat details"));
}
if (!AuthenticationUtilities.IsAllowedChat(User))
{
return(BadRequest("User has been banned from Chat"));
}
return(Ok(await _chatService.EditChatAsync(details, ct)));
}
public async Task <IActionResult> UploadFeedMediaAttachment()
{
if (!AuthenticationUtilities.IsAllowedFeed(User))
{
return(BadRequest("User has been banned from Feed"));
}
if (HttpContext.Request.Form.Files.Count > 0)
{
return(Ok(await _feedService.UploadMediaAttachmentAsync(HttpContext.Request.Form.Files[0])));
}
return(BadRequest());
}
public async Task <IActionResult> CommentOnPost([FromBody] FeedComment comment, CancellationToken ct = default)
{
if (!AuthenticationUtilities.IsAllowedFeed(User))
{
return(BadRequest("User has been banned from Feed"));
}
if (!AuthenticationUtilities.IsSameUser(User, comment.UserUUID))
{
return(Unauthorized("You do not have access to comment for this user"));
}
return(Ok(await _feedService.AddCommentToPostAsync(comment, ct)));
}
public async Task <IActionResult> UploadAditLogAttachment(bool isVideo = false, CancellationToken ct = default)
{
if (!AuthenticationUtilities.IsAllowedFeed(User))
{
return(BadRequest("User has been banned from Feed"));
}
if (HttpContext.Request.Form.Files.Count >= 1)
{
return(Ok(await _feedService.UploadAditLogMediaAsync(HttpContext.Request.Form.Files.FirstOrDefault(), isVideo, ct: ct)));
}
return(BadRequest("No files uploaded"));
}
public async Task <IActionResult> ToggleLikeForPost(int feedPostId, string userUUID, CancellationToken ct = default)
{
if (!AuthenticationUtilities.IsSameUser(User, userUUID))
{
return(Unauthorized("You do not have access to Like for this user"));
}
if (!AuthenticationUtilities.IsAllowedFeed(User))
{
return(BadRequest("User has been banned from Feed"));
}
await _feedService.ToggleLikeForPostAsync(feedPostId, userUUID, ct);
return(Ok());
}
