/// <summary>
/// Retunr the QuoteVoteUid To make it possible to vote using it
/// </summary>
/// <param name="quoteEvent"></param>
/// <returns></returns>
public async Task <String> ReceiveNewQuoteEvent(SlackEventRequestModel quoteEvent)
{
try
{
return(await processNewQuoteEvent(quoteEvent));
}
catch (global::System.Exception)
{
throw;
}
}
public IActionResult SlackVerification([FromBody] SlackEventRequestModel request)
{
try
{
return(Ok(_slackRepository.ProcessRequest(request)));
}
catch (Exception e)
{
_logger.LogError($"Erro ao receber evento do slack: {e}");
return(BadRequest());
}
}
public async Task SendMessage(SlackEventRequestModel quote, string quoteVoteUid)
{
try
{
var message = $"Nova quote: '{quote.text}'; User para votar o id: {quoteVoteUid}!";
MessageToChannelMode messageModel = await prepareMessageToChannelModel(message, quote.channel_id);
await _slackApiHelper.SendMessageToChannel(messageModel);
}
catch (System.Exception e)
{
throw;
}
}
public async Task <IActionResult> Downvote([FromForm] SlackEventRequestModel upvote)
{
try
{
await _quotesRepository.DownvoteAsync(upvote);
return(Ok());
}
catch (Exception e)
{
_logger.LogError($"Não foi possivel adicionar voto para quote: {e}");
return(BadRequest());
}
}
private async Task upvoteQuoteTwiceTest()
{
using (var ctx = new ApplicationDbContext(options))
{
var repository = new QuoteRepository(ctx);
SlackEventRequestModel upvoteRequest = await getSlackEventRequestModel();
await repository.UpvoteAsync(upvoteRequest);
await Assert.ThrowsAnyAsync <Exception>(
async() =>
await repository.UpvoteAsync(upvoteRequest)
);
}
}
private async Task upVoteTestSuccess(ApplicationDbContext ctx)
{
var repository = new QuoteRepository(ctx);
SlackEventRequestModel upvoteRequest = await getSlackEventRequestModel();
await repository.UpvoteAsync(upvoteRequest);
var quoteInDb = await ctx.Quote.Include(q => q.Votes)
.FirstOrDefaultAsync();
var vote = quoteInDb.Votes[0];
Object.Equals(1, vote.Vote);
Object.Equals(vote.UserSlackId, "SLACK");
}
private async Task <SlackEventRequestModel> getSlackEventRequestModel()
{
var userId = await AddUser(false);
var upvoter = await AddUser(true);
var quoteVoteUid = await AddQuote(userId, upvoter);
var upvoteRequest = new SlackEventRequestModel()
{
user_id = upvoter,
text = "1111",
};
return(upvoteRequest);
}
public async Task DownvoteAsync(SlackEventRequestModel request)
{
try
{
var quote = await validadeVoteRequest(request);
//To Do
//Verify if user exists, if not request its information
short voteValue = -1;
await saveVote(request, voteValue, quote);
}
catch (Exception)
{
throw;
}
}
public async Task <IActionResult> AddQuote([FromForm] SlackEventRequestModel quote)
{
try
{
var quoteVoteUid = await _quotesRepository.ReceiveNewQuoteEvent(quote);
await _slackRepository.SendMessage(quote, quoteVoteUid);
return(Ok());
}
catch (Exception e)
{
_logger.LogError($"Não foi possivel adicionar quote: {e}");
return(BadRequest());
}
}
public async Task TestVerification()
{
using (var ctx = new ApplicationDbContext(options))
{
var repository = new SlackRepository(ctx);
var request = new SlackEventRequestModel()
{
challenge = "MAH_XALENDI",
token = "MAH_TOQUIN",
type = "url_verification"
};
var response = await repository.ProcessRequest(request);
Assert.Equal(request.challenge, response);
}
}
private async Task saveQuote(SlackEventRequestModel quoteEvent, string quote, string authorId)
{
var snitchId = await _context.User
.FirstOrDefaultAsync(u => u.SlackId == quoteEvent.user_id);
var quoteModel = new QuoteModel()
{
Content = quote,
Date = DateTimeOffset.UtcNow,
Upvotes = 0,
Downvotes = 0,
SnitchId = authorId,
UserId = authorId
};
await _context.Quote.AddAsync(quoteModel);
await _context.SaveChangesAsync();
}
private async Task <string> saveQuoteInDb(SlackEventRequestModel quoteEvent, string authorId, string content)
{
string quoteVoteUid = await getUniqueQuoteVoteId();
var snitchId = _context.User.FirstOrDefault(u => u.SlackId == quoteEvent.user_id).UserId;
var quote = new QuoteModel()
{
Content = content,
SnitchId = snitchId,
UserId = authorId,
Date = DateTimeOffset.Now,
QuoteVoteUid = quoteVoteUid
};
await _context.AddAsync(quote);
await _context.SaveChangesAsync();
return(quoteVoteUid);
}
private async Task <string> processNewQuoteEvent(SlackEventRequestModel quoteEvent)
{
string authorName = null;
string authorId = null;
var content = quoteEvent.text;
if (string.IsNullOrWhiteSpace(quoteEvent.text))
{
throw new Exception("Quote vazio");
}
var byPosition = quoteEvent.text.LastIndexOf("by:");
if (byPosition > 0)
{
var authorString = quoteEvent.text.Split("by:");
if (string.IsNullOrWhiteSpace(authorString[0]))
{
throw new Exception("Quote vazio");
}
content = authorString[0];
if (authorString.Count() > 2)
{
authorName = null;
}
else
{
authorName = authorString[1].Replace("@", "").Replace(" ", "");;
var author = await _context.User.FirstOrDefaultAsync(
u => u.Name == authorName || u.RealName == authorName
);
if (author != null)
{
authorId = author.UserId;
}
}
}
return(await saveQuoteInDb(quoteEvent, authorId, content));
}
private async Task addNewQuoteEventTest(string input, string text, string author)
{
using (var ctx = new ApplicationDbContext(options))
{
var repository = new QuoteRepository(ctx);
var addedUserId = await AddUser(false);
var snitchId = await AddUser(true);
var userId = String.IsNullOrEmpty(author) ? null : addedUserId;
var slackEvent = new SlackEventRequestModel()
{
user_id = snitchId,
text = input,
};
await assertAddNewQuoteEventTst(text, ctx, repository, userId, snitchId, slackEvent);
}
}
private async Task saveVote(SlackEventRequestModel request, short voteValue, QuoteModel quote)
{
var vote = new VoteModel()
{
QuoteVoteUid = request.text,
UserSlackId = request.user_id,
Vote = voteValue,
QuoteId = quote.QuoteId
};
if (vote.Vote > 0)
{
quote.Upvotes++;
}
else
{
quote.Downvotes++;
}
await _context.AddAsync(vote);
await _context.SaveChangesAsync();
}
private async Task <QuoteModel> validadeVoteRequest(SlackEventRequestModel request)
{
if (request.text.Split(' ').Count() > 1)
{
throw new Exception($"Requeste invalido: {request.text}");
}
var quote = await _context.Quote.
FirstOrDefaultAsync(v => v.QuoteVoteUid == request.text);
if (quote is null)
{
throw new Exception($"Quote não existe id:{request.text}");
}
if (await _context.VoteModels.AnyAsync(v => v.QuoteVoteUid == request.text &&
v.UserSlackId == request.user_id))
{
throw new Exception(
$"Usuario ja votou para essa quote Uid:{request.user_id} {request.text}");
}
return(quote);
}
public async Task <string> ProcessRequest(SlackEventRequestModel request)
{
try
{
string response = null;
switch (request.type)
{
case "url_verification":
response = request.challenge;
break;
case "message":
break;
default:
break;
}
return(response);
}
catch (System.Exception)
{
throw;
}
}
private async Task processEvent(SlackEventRequestModel quoteEvent)
{
throw new System.NotImplementedException();
}
private static async Task assertAddNewQuoteEventTst(string text, ApplicationDbContext ctx, QuoteRepository repository, string userId, string snitchId, SlackEventRequestModel slackEvent)
{
await repository.ReceiveNewQuoteEvent(slackEvent);
var quoteInDb = await ctx.Quote.FirstOrDefaultAsync();
Assert.Equal(userId, quoteInDb.UserId);
Assert.Equal(snitchId, quoteInDb.SnitchId);
Assert.Equal(text, quoteInDb.Content);
}
public async Task <string> ProcessRequest(SlackEventRequestModel request)
{
throw new System.NotImplementedException();
}
