public async Task <IActionResult> CreateChat([Bind("ChatID,MsgCount,UserOne")] Chat chat)
{
if (ModelState.IsValid)
{
var User = await _userManager.GetUserAsync(HttpContext.User);
var selectUser = await _userManager.Users.ToListAsync();
//foreach (var u in selectUser)
//{
// if (u.Id == chat.UserOne)
// {
// chat.UserOne = u.UserName;
// }
//}
chat.UserTwo = User.Id;
_context.Add(chat);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(chat));
}
public async Task <IActionResult> Create([Bind("ChatID,MsgCount,UserOne")] Chat chat)
{
if (ModelState.IsValid)
{
var User = await _userManager.GetUserAsync(HttpContext.User);
var selectUser = await _userManager.Users.ToListAsync();
foreach (var u in selectUser)
{
if (u.Id == chat.UserOne)
{
chat.UserOne = u.UserName;
}
}
chat.UserTwo = HttpContext.User.FindFirstValue(ClaimTypes.Name);
_context.Add(chat);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(chat));
}
public static async Task SeedScenarios(this ChatContext context, IGuideService guideService, ILogger logger)
{
var all = guideService.GetAllScenarioGuide();
foreach (var scenarioGuide in all)
{
logger.LogDebug($"Seeding scenario scenario {scenarioGuide.ScenarioId}");
try
{
var scenario = new Scenario()
{
Id = scenarioGuide.ScenarioId,
Name = scenarioGuide.ScenarioName,
Description = scenarioGuide.Description
};
if (context.Scenarios.FirstOrDefault(item => item.Id == scenario.Id) != null)
{
continue;
}
context.Add(scenario);
var i = 1;
foreach (var goalGuide in scenarioGuide.Goals)
{
logger.LogDebug($"Seeding scenario scenario {goalGuide.Id}");
var goal = new Goal()
{
Id = goalGuide.Id,
Order = i,
ScenarioId = scenarioGuide.ScenarioId,
Text = goalGuide.GoalName
};
if (context.Goals.FirstOrDefault(item => item.Id == goal.Id) != null)
{
continue;
}
context.Add(goal);
i++;
}
}
catch (Exception ex)
{
logger.LogError("Failed duering addition of new scenario.", ex);
}
}
await context.SaveChangesAsync();
}
public async Task SendMessage(string message)
{
_context.Add <Chat>(new Chat {
UserID = Current.UserID, ChatDate = DateTime.Now, ChatText = message
});
await _context.SaveChangesAsync();
var user = Current.UserNickName;
await Clients.All.SendAsync("ReceiveMessage", user, message);
}
public bool AddNewMessage(ChatMessage message)
{
if (_context.Messages.Any(item => item.Id == message.Id))
{
return(false);
}
_context.Add(message);
_context.SaveChanges();
return(true);
}
public IActionResult Create(Message mes)
{
mes.UserId = 1;
mes.When = DateTime.Now;
_db.Add(mes);
_db.SaveChanges();
return(RedirectPermanent("~/Home/Index"));
}
public async Task <IActionResult> Create([Bind("Id,User,Message")] Chater chater)
{
if (ModelState.IsValid)
{
_context.Add(chater);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(chater));
}
public async Task <IActionResult> Create([Bind("EmployeeId,FirstName,LastName,SecondName,Age,Phone,Email,Sex,WorkTime,PasswordHash,EmployeeGuid")] Employee employee)
{
if (ModelState.IsValid)
{
_context.Add(employee);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["WorkTime"] = new SelectList(_context.WorkTimes, "WorkTimeId", "WorkTimeId", employee.WorkTime);
return(View(employee));
}
public void AddChatToDB(Player aPlayer, Chat aChat)
{
using (var DB = new ChatContext())
{
DB.Add(aChat);
DB.SaveChanges();
}
if (aChat.Type == (byte)ChatType.Global)
{
ChatHub?.Clients.All.SendAsync("Send", JsonConvert.SerializeObject(aChat));
}
else
{
ChatHub?.RoleSendAsync(aPlayer, "Send", JsonConvert.SerializeObject(aChat));
}
}
public async Task SendChat(string value, string groupName)
{
using (var db = new ChatContext())
{
var chatRoom = db.ChatRooms.Single(x => x.name == groupName);
/*
* For now, we'll keep the UserId = 1 and TimeStamp to 2 Feb.
* Will be changed in the very future of course.
*
*/
db.Add(new Chat {
UserId = 1,
Content = value,
TimeStamp = "2 Feb",
ChatRoom = chatRoom
});
db.SaveChanges();
}
await Clients.Group(groupName).SendAsync("ReceiveMessageSelf", value);
}
private async Task <dynamic> SendMessageAsync(dynamic parameters, CancellationToken cancellationToken)
{
var request = this.Bind <SendMessageRequest>();
var message = new Message
{
MessageText = request.MessageText,
SenderId = request.SenderId,
TargetId = request.TargetId,
ChannelId = request.ChannelId,
TimeSent = DateTime.Now.ToUniversalTime()
};
context.Add(message);
await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
message.Sender = User;
var response = JsonConvert.SerializeObject(message);
await notificationHandler.SendToRoom(response, request.ChannelId);
return(Response.AsJson(message));
}
public async Task <MessageDto> SaveMessage(string user, string messageText, CancellationToken token)
{
if (string.IsNullOrWhiteSpace(user))
{
throw new ArgumentNullException(nameof(user));
}
var message = new Message
{
InsertDate = DateTime.UtcNow,
MessageText = messageText,
UserName = user
};
context.Add(message);
await context.SaveChangesAsync(token);
return(new MessageDto
{
Id = message.Id,
MessageText = message.MessageText,
User = message.UserName
});
}
public void AddMessage(Message message)
{
_context.Add(message);
}
public void Add(Group obj)
{
_chatContext.Add(obj);
}
public UserChannel Add(UserChannel entity)
{
_chatContext.Add(entity);
return(entity);
}
