public ActionResult PostMessageModified(int messageId, string version)
{
var versionEncryptedBytes = MachineKeySectionWrapper.HexStringToByteArray(version);
var versionBytes = MachineKeySectionWrapper.Decrypt(versionEncryptedBytes);
var yesterday = DateTime.Now.AddDays(-1);
var message = new SimplifiedMessage
{
Id = messageId,
Version = versionBytes,
Created = yesterday,
Modified = yesterday,
Number = yesterday.Millisecond.ToString()
};
try
{
MessageRepository.UpdateMessage(message);
}
catch (ConcurrencyException)
{
return(new HttpStatusCodeResult((int)HttpStatusCode.InternalServerError, "Concurrency error"));
}
return(this.Json(message, JsonRequestBehavior.AllowGet));
}
public Response GenerateResponse(SimplifiedMessage simplified)
{
var leading = _truthLieRepository.GetLeading();
var member = _truthLieRepository.Get(simplified.Author);
if (member == null)
{
member = new TruthLiePlayer {
VkId = simplified.Author, Status = TruthLieStatus.WaitingStart
};
_truthLieRepository.InsertOrUpdate(member);
}
switch (leading?.Status)
{
case null:
break;
case TruthLieStatus.FirstTruth:
case TruthLieStatus.SecondTruth:
case TruthLieStatus.Lie:
break;
case TruthLieStatus.WaitingFinish:
break;
}
return(new Response(ResponseType.None));
}
private Response GenerateText(SimplifiedMessage message)
{
var last = message.MustReply ? message.Words.LastOrDefault() : null;
return(new Response(ResponseType.Text)
{
Content = _memory.Generate(last)
});
}
public Response GetResponse(Message message)
{
_memory.SaveUserChat(message.ChatId, message.UserId);
if (string.IsNullOrEmpty(message.Text))
{
return(null);
}
var settings = Settings.Get(_settingsPath);
var simplified = new SimplifiedMessage(message, _botNames);
if (settings.Status == BotStatus.TruthOrLieGame)
{
return(_truthLieGame.GenerateResponse(simplified));
}
var response = new Response(ResponseType.None);
if (simplified.MustReply)
{
response = ReplyOnCommand(simplified.Words, settings.GetUserStatus(message.FromId));
}
response = response.Type switch
{
ResponseType.SettingChange when response.Setting != null => settings.Set(response.Setting.Value, response.Content),
ResponseType.Status => SetupStatusResponse(response, settings),
ResponseType.UserPick => SetupUserPickResponse(response, simplified.ChatId),
_ => response
};
if (response.Type == ResponseType.None && !simplified.Tagged)
{
_memory.Save(simplified.Words, settings.LastWord);
settings.LastWord = simplified.Words.LastOrDefault();
}
if (settings.Status == BotStatus.Talk)
{
settings.Save(_settingsPath);
}
if (response.Type != ResponseType.None)
{
return(response);
}
if (settings.Status == BotStatus.Talk && (simplified.MustReply || settings.RandomReply()))
{
return(GenerateText(simplified));
}
return(response);
}
public SimplifiedMessage UpdateMessage(SimplifiedMessage message)
{
try
{
MessageRepository.UpdateMessage(message);
return(message);
}
catch (ConcurrencyException)
{
var ex = new FaultException <ConcurrencyFault>(
new ConcurrencyFault(), "Concurrency exception.");
throw ex;
}
}
public static void UpdateMessage(SimplifiedMessage message)
{
using (var context = new versioningEntities())
{
context.SimplifiedMessages.Attach(message);
context.Entry(message).State = EntityState.Modified;
try
{
context.SaveChanges();
}
catch (DbUpdateConcurrencyException updateConcurrencyException)
{
var ex = new ConcurrencyException("Update failed.", updateConcurrencyException);
throw ex;
}
}
}
