public async Task <IActionResult> PutScenario(int id, Scenario scenario)
{
if (id != scenario.Id)
{
return(BadRequest());
}
_context.Entry(scenario).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ScenarioExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Verify(String email, String code)
{
var login = await _context.Logins.FindAsync(email);
if (login == null)
{
ViewBag.Message = String.Format("Verification fail! Email is not available");
return(View());
}
else if (login.Code != code)
{
ViewBag.Message = String.Format("Verification fail! Verification code is incorrect");
return(View());
}
else if (login.Activate == true)
{
ViewBag.Message = String.Format("This account already verified");
return(View());
}
else
{
ViewBag.Message = String.Format("Verification successfully");
login.Verify();
await _context.SaveChangesAsync(); //save changes
return(View());
}
}
public async Task <IHttpActionResult> PutMessage(int id, Message message)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != message.Id)
{
return(BadRequest());
}
db.Entry(message).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MessageExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IActionResult> PutConversation([FromRoute] int id, [FromBody] Conversation conversation)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != conversation.Id)
{
return(BadRequest());
}
_context.Entry(conversation).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ConversationExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
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 async Task <IActionResult> PutMessage(long id, Message message)
{
if (id != message.MessageId)
{
return(BadRequest());
}
_context.Entry(message).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MessageExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> OnPostSendJoinRequestAsync(string returnUrl = null)
{
returnUrl ??= Url.Content("~/");
var group = await _context.Group
.OfType <MultiuserGroup>()
.Include(g => g.BannedUsers)
.FirstOrDefaultAsync(g => g.GroupID == SendJoinRequestInput.GroupID);
if (group.BannedUsers.FirstOrDefault(u => u.Id == SendJoinRequestInput.ChatUserID) != null)
{
return(BadRequest());
}
GroupJoinRequest request = new GroupJoinRequest()
{
ChatUserID = SendJoinRequestInput.ChatUserID,
GroupID = group.GroupID,
Message = SendJoinRequestInput.Message,
DateSent = DateTime.Now
};
await _context.GroupJoinRequest.AddAsync(request);
await _context.SaveChangesAsync();
return(LocalRedirect(returnUrl));
}
public async Task <IActionResult> PostChatUser([FromBody] ChatUser chatUser)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.ChatUsers.Add(chatUser);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (ChatUserExists(chatUser.ChatId))
{
return(new StatusCodeResult(StatusCodes.Status409Conflict));
}
else
{
throw;
}
}
return(CreatedAtAction("GetChatUser", new { id = chatUser.ChatId }, chatUser));
}
public async Task <IActionResult> PutChater(int id, Chater chater)
{
if (id != chater.Id)
{
return(BadRequest());
}
_context.Entry(chater).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ChaterExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <string> CreateAsync(AboutUser model, string userId)
{
context.AboutUsers.Add(model);
await context.SaveChangesAsync();
return(userId);
}
public async Task <ActionResult <TodoItem> > NewChatRoom(ChatRoom item)
{
_context.ChatRooms.Add(item);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetChatRoom), new { id = item.Id }, item));
}
public async Task <Models.Chat> Create(Models.Chat chat)
{
var createdChat = await _context.Chats.AddAsync(chat);
await _context.SaveChangesAsync();
return(createdChat.Entity);
}
public async Task AcceptFriendRequest(FriendRequestVM friendRequest)
{
var update = await _chatContext.FriendRequest
.Where(p => p.FromUser == friendRequest.FromUser && p.ToUser == friendRequest.ToUser)
.FirstOrDefaultAsync();
update.HasAccepted = true;
await _chatContext.SaveChangesAsync();
}
public async Task <Message> Create(Message message)
{
message.Date = DateTime.UtcNow;
var createdMessage = await _context.Messages.AddAsync(message);
await _context.SaveChangesAsync();
return(createdMessage.Entity);
}
public async Task <User> Create(User user)
{
user.Password = Security.HashPassword(user.Password);
user.CreationDate = DateTime.UtcNow;
var createdUser = await _context.Users.AddAsync(user);
await _context.SaveChangesAsync();
return(createdUser.Entity);
}
public async Task <IActionResult> OnPost(string name)
{
await _chatContext.Rooms.AddAsync(new Room()
{
Name = name
});
await _chatContext.SaveChangesAsync();
return(ViewComponent("Rooms"));
}
// send message to the whole group
public async Task SendToAll(Message message)
{
_logger.LogInformation($"Sending message: {message?.Text} to group: {message?.SessionName}");
await Clients.Groups(message.SessionName).SendAsync("message", message);
await _context.AddAsync(message);
await _context.SaveChangesAsync();
await SendToBot(message);
}
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));
}
private async Task SaveProfileImageAsync(ProfileImageVM profileImageVM)
{
var dbModel = new ProfileImage
{
ProfileImage1 = profileImageVM.ProfileImage1,
UserId = profileImageVM.UserId
};
_chatContext.ProfileImage.Add(dbModel);
await _chatContext.SaveChangesAsync();
}
public async Task AddGroupChatAsync(GroupChatVM groupChatVM)
{
var dbModel = new GroupChat
{
GroupName = groupChatVM.GroupName,
GroupAdminId = groupChatVM.GroupAdminId,
ExitGroup = false
};
_chatContext.GroupChat.Add(dbModel);
await _chatContext.SaveChangesAsync();
}
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 async Task AddRoom(Room room, string userId)
{
//создать можно только одну Main комнату
if (!_context.Rooms.Any())
{
var modelDb = _mapper.Map <RoomDb>(room);
modelDb.OwnerId = userId;
await _context.Rooms.AddAsync(modelDb);
await _context.SaveChangesAsync();
}
}
private async Task <dynamic> RemoveUserAsync(dynamic parameters, CancellationToken cancellationToken)
{
var request = this.Bind <UnsignRoleRequest>();
var userteam = await context.UserTeams.FirstAsync(
ut => ut.TeamId == request.TeamId && ut.UserId == request.UserId, cancellationToken).ConfigureAwait(false);
context.UserTeams.Remove(userteam);
await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
return(Response.AsJson(new Msg("User Removed")));
}
private async Task <dynamic> DeleteChannelAsync(dynamic parameters, CancellationToken cancellationToken)
{
int id = parameters.id;
context.Channels.Remove(new Channel {
Id = id
});
await context.SaveChangesAsync(cancellationToken)
.ConfigureAwait(false);
return(Response.AsJson(new Msg("Channel Deleted")));
}
public async Task <IActionResult> PutChat([FromRoute] int id, [FromBody] Message message)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _context.Users.FindAsync(message.UserId);
var chat = await _context.Chats.Include(m => m.ChatMessages).Include(p => p.ChatUsers)
.FirstOrDefaultAsync(i => i.ChatId == id);
if (chat == null)
{
return(NotFound());
}
if (user == null)
{
return(NotFound());
}
if (!chat.ChatUsers.Where(n => n.UserId == message.UserId).Any())
{
ChatUser chatUser = new ChatUser();
chatUser.Chat = chat;
chatUser.User = user;
_context.ChatsUsers.Add(chatUser);
await _context.SaveChangesAsync();
}
chat.ChatMessages.Add(message);
_context.Entry(chat).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ChatExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public Task Send(Message message)
{
message.EventId = Event.Message.GetHashCode();
message.CreatedDate = DateTime.Now;
var userChat = chatContext.UsersChat.AsNoTracking().FirstOrDefault(x => x.ConnectionId == Context.ConnectionId);
if (userChat != null)
{
message.UserChatId = userChat.UserChatId;
chatContext.Messages.Add(message);
chatContext.SaveChangesAsync();
}
return(Clients.All.SendAsync("ReceiveMessage", message));
}
private async Task <dynamic> ChangePasswordAsync(dynamic parameters, CancellationToken cancellationToken)
{
var request = this.Bind <ChangePasswordRequest>();
var user = await context.Users.FindAsync(request.UserId).ConfigureAwait(false);
if (!BCrypt.Net.BCrypt.EnhancedVerify(request.OldPassword, user.Password))
{
return(Response.AsJson(new Msg("Wrong input for old password")).WithStatusCode(HttpStatusCode.BadRequest));
}
user.Password = BCrypt.Net.BCrypt.EnhancedHashPassword(request.NewPassword);
await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
return(Response.AsJson(new Msg("Password changed successfully")));
}
/// <summary>
/// Soft-deletes the user.
/// </summary>
/// <returns></returns>
public async Task <bool> DeleteAsync(ChatContext chatContext)
{
FirstName = null;
LastName = null;
ProfileDescription = null;
IsEnabled = false;
foreach (Membership m in Memberships)
{
chatContext.Remove(m);
}
foreach (GroupJoinInvitation i in GroupJoinInvitations)
{
chatContext.Remove(i);
}
foreach (PersonalChatInvitation i in PersonalChatInvitations)
{
chatContext.Remove(i);
}
foreach (Notification n in Notifications)
{
chatContext.Remove(n);
}
await chatContext.SaveChangesAsync();
return(true);
}
public async Task PostAsync([FromBody] LogBook value)
{
value.logBookId = Guid.NewGuid();
value.logBookDate = DateTime.Now;
context.logBooks.Add(value);
await context.SaveChangesAsync();
}
public async Task <IActionResult> OnPostConfirmAsync(string returnUrl = null)
{
returnUrl ??= Url.Content("~/");
var membership = await _context.Membership
.OfType <MultiuserGroupMembership>()
.Include(m => m.Group)
.Include(m => m.ChatUser)
.FirstOrDefaultAsync(m => m.MembershipID == MembershipIDInput);
if (membership == null)
{
return(BadRequest());
}
var currentUser = await _userManager.GetUserAsync(User);
if (membership.ChatUserID != currentUser.Id)
{
return(BadRequest());
}
if (membership.Rank < PermissionRank.OWNER.Ordinal)
{
return(Forbid());
}
_context.Group.Remove(membership.Group);
await _context.SaveChangesAsync();
return(LocalRedirect("/Groups"));
}
