// The id parameter name should match the DataKeyNames value set on the control
public void MessagesListView_DeleteItem(int Id)
{
var db = new ChatDbContext();
var selected = db.Messages.Find(Id);
db.Messages.Remove(selected);
db.SaveChanges();
}
// The return type can be changed to IEnumerable, however to support
// paging and sorting, the following parameters must be added:
// int maximumRows
// int startRowIndex
// out int totalRowCount
// string sortByExpression
public IQueryable<Message> lvMessages_GetData()
{
var db = new ChatDbContext();
return db.Messages
.AsQueryable()
.OrderByDescending(m => m.CreationDate)
.Take(10)
.OrderBy(m => m.CreationDate);
}
protected void SaveMessage_Click(object sender, EventArgs e)
{
var db = new ChatDbContext();
var item = new Message();
item.CreationDate = DateTime.Now;
item.UserId = this.User.Identity.GetUserId();
item.Content = this.Content.Text;
db.Messages.Add(item);
db.SaveChanges();
this.Content.Text = string.Empty;
lvMessages.DataBind();
}
public void lvMessages_InsertItem()
{
var db = new ChatDbContext();
var item = new Message();
TryUpdateModel(item);
if (ModelState.IsValid)
{
item.CreationDate = DateTime.Now;
db.Messages.Add(item);
db.SaveChanges();
}
}
public void MessagesListView_InsertItem()
{
var item = new Message();
TryUpdateModel(item);
item.CreationDate = DateTime.Now;
item.UserId = this.User.Identity.GetUserId();
if (ModelState.IsValid)
{
var db = new ChatDbContext();
db.Messages.Add(item);
db.SaveChanges();
}
}
// The id parameter name should match the DataKeyNames value set on the control
public void MessagesListView_UpdateItem(int Id)
{
var db = new ChatDbContext();
Message item = db.Messages.Find(Id);
if (item == null)
{
// The item wasn't found
ModelState.AddModelError("", String.Format("Item with id {0} was not found", Id));
return;
}
TryUpdateModel(item);
if (ModelState.IsValid)
{
db.SaveChanges();
}
}
private void btnLogin_Click(object sender, EventArgs e)
{
using (ChatDbContext db = new ChatDbContext())
{
var result = db.UserTypes.FirstOrDefault(x => x.Id == (int)UserTypes.Client);
if (result == null)
{
db.UserTypes.Add(new UserType()
{
UserTypeName = "Server"
});
db.SaveChanges();
db.UserTypes.Add(new UserType()
{
UserTypeName = "Client"
});
db.SaveChanges();
}
var resultUser = db.Users.FirstOrDefault(x => x.UserName == txtUserName.Text.ToLower().Trim() || x.Password == txtPassword.Text);
if (resultUser == null)
{
var addUser = db.Users.Add(new User()
{
UserName = txtUserName.Text.ToLower().Trim(),
Password = txtPassword.Text,
UserTypeID = (int)UserTypes.Client,
});
db.SaveChanges();
}
else
{
LoginViewModel.UserName = resultUser.UserName;
LoginViewModel.UserID = resultUser.Id;
this.Hide();
frmClient frmClient = new frmClient();
frmClient.Show();
}
}
}
public void Connect(string userName, string email)
{
emailIDLoaded = email;
var id = Context.ConnectionId;
using (ChatDbContext dbContext = new ChatDbContext(connectionString))
{
var connectedChatUser = dbContext.ChatUserDetails.FirstOrDefault(x => x.EmailAddress == email);
if (connectedChatUser != null)
{
dbContext.ChatUserDetails.Remove(connectedChatUser);
dbContext.SaveChanges();
// Disconnect the already existing user with same email id
Clients.All.onUserDisconnectedExisting(connectedChatUser.ConnectionId, connectedChatUser.UserName);
}
var Users = dbContext.ChatUserDetails.ToList();
if (Users.Where(x => x.EmailAddress == email).ToList().Count == 0)
{
var userdetails = new ChatUserDetail
{
ConnectionId = id,
UserName = userName,
EmailAddress = email
};
dbContext.ChatUserDetails.Add(userdetails);
dbContext.SaveChanges();
// send to caller
var connectedUsers = dbContext.ChatUserDetails.ToList();
var CurrentMessage = dbContext.ChatMessageDetails.ToList();
//Establish connect with message, user name and connected users list
Clients.Caller.onConnected(id, userName, connectedUsers, CurrentMessage);
}
// send to all except caller client
Clients.AllExcept(id).onNewUserConnected(id, userName, email);
}
}
private static void ImportMessageToDatabase(MessageDto message)
{
if (string.IsNullOrWhiteSpace(message.Content))
{
throw new ArgumentException("Content is required");
}
if (string.IsNullOrWhiteSpace(message.Recipient))
{
throw new ArgumentException("Recipient is required");
}
if (string.IsNullOrWhiteSpace(message.Sender))
{
throw new ArgumentException("Sender is required");
}
var context = new ChatDbContext();
var recipientId = context.Users
.Where(x => x.Username == message.Recipient)
.Select(x => x.Id)
.FirstOrDefault();
var senderId = context.Users
.Where(x => x.Username == message.Sender)
.Select(x => x.Id)
.FirstOrDefault();
var newMessage = new UserMessage
{
Content = message.Content,
DateTime = message.DateTime,
RecipientId = recipientId,
SenderId = senderId
};
context.UserMessages.Add(newMessage);
context.SaveChanges();
}
public async Task MessageLoader(string id1, string id2)
{
using (ChatDbContext db = new ChatDbContext())
{
var messages = (from message in db.Msgs
where (message.IdFrom == id1 && message.IdTo == id2) || (message.IdTo == id1 && message.IdFrom == id2)
select message).ToList();
foreach (var item in messages)
{
if (item.IdFrom == id1)
{
await Clients.Caller.SendAsync("SendLeft", item.EmailFrom.Remove(item.EmailFrom.IndexOf('\x40')) + ": ", item.Message, item.Time.ToString("hh.mm"));
}
else
{
await Clients.Caller.SendAsync("SendRight", item.EmailFrom.Remove(item.EmailFrom.IndexOf('\x40')) + ": ", item.Message, item.Time.ToString("hh.mm"));
item.Read = true;
}
}
await db.SaveChangesAsync();
}
}
// GET: Chat
public ActionResult Index()
{
using (var db = new ChatDbContext())
{
var groups = db.Groups.OrderBy(x => x.GroupName).ToList();
var user = db.Users.Include(u => u.Groups).SingleOrDefault(u => u.UserName == User.Identity.Name);
if (user != null)
{
var mygroups = user.Groups.OrderBy(x => x.GroupName).ToList();
ViewBag.MyGroupId = new SelectList(mygroups, "GroupName", "GroupName");
}
else
{
ViewBag.MyGroupId = new SelectList(new[] { new Group()
{
GroupName = "Public"
} }, "GroupName", "GroupName");;
}
ViewBag.GroupId = new SelectList(groups, "GroupName", "GroupName");
return(View());
}
}
public Repository(ChatDbContext context)
{
Db = context;
DbSet = Db.Set <T>();
}
public ChatMessagesController(ChatDbContext context)
{
_context = context;
}
public IQueryable <Person> GetPersonByIdAsync(
Guid id,
[Service] ChatDbContext dbContext) =>
dbContext.People.Where(t => t.Id == id);
public IQueryable <Person> GetPersonByEmailAsync(
string email,
[Service] ChatDbContext dbContext) =>
dbContext.People.Where(t => t.Email == email);
public MessageController(IMapper mapper, ChatDbContext context)
{
this.context = context;
this.mapper = mapper;
}
public UserRepository(ChatDbContext context) : base(context)
{
}
public void SetCrocoApplication(IServiceCollection services)
{
var memCache = new MemoryCache(new MemoryCacheOptions());
services.AddSingleton <IMemoryCache, MemoryCache>(s => memCache);
var baseOptions = new EFCrocoApplicationOptions
{
CacheManager = new ApplicationCacheManager(memCache),
GetDbContext = () => ChatDbContext.Create(Configuration),
RequestContextLogger = new CrocoWebAppRequestContextLogger(),
FileOptions = new CrocoFileOptions
{
SourceDirectory = Env.WebRootPath,
ImgFileResizeSettings = new List <ImgFileResizeSetting>
{
new ImgFileResizeSetting
{
ImageSizeName = ImageSizeType.Icon.ToString(),
MaxHeight = 50,
MaxWidth = 50
},
new ImgFileResizeSetting
{
ImageSizeName = ImageSizeType.Small.ToString(),
MaxHeight = 200,
MaxWidth = 200
},
new ImgFileResizeSetting
{
ImageSizeName = ImageSizeType.Medium.ToString(),
MaxHeight = 500,
MaxWidth = 500
}
},
},
RootPath = Env.ContentRootPath,
AfterInitActions = ApplicationActions
}.GetApplicationOptions();
baseOptions.AddDelayedApplicationLogger()
.AddHangfireEventSourcerAndJobManager();
var options = new CrocoWebApplicationOptions()
{
ApplicationUrl = "https://findtask.ru",
CrocoOptions = baseOptions,
};
var application = new MyCrocoWebApplication(options)
{
IsDevelopment = Env.EnvironmentName == "Development"
};
CrocoApp.Application = application;
services.AddSingleton(CrocoApp.Application);
}
public async Task <CreateUserPayload> CreateUser(
CreateUserInput input,
[Service] ChatDbContext dbContext,
CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(input.Name))
{
throw new QueryException(
ErrorBuilder.New()
.SetMessage("The name cannot be empty.")
.SetCode("USERNAME_EMPTY")
.Build());
}
if (string.IsNullOrEmpty(input.Email))
{
throw new QueryException(
ErrorBuilder.New()
.SetMessage("The email cannot be empty.")
.SetCode("EMAIL_EMPTY")
.Build());
}
if (string.IsNullOrEmpty(input.Password))
{
throw new QueryException(
ErrorBuilder.New()
.SetMessage("The password cannot be empty.")
.SetCode("PASSWORD_EMPTY")
.Build());
}
string salt = Guid.NewGuid().ToString("N");
using var sha = SHA512.Create();
byte[] hash = sha.ComputeHash(Encoding.UTF8.GetBytes(input.Password + salt));
Guid personId = Guid.NewGuid();
var user = new User
{
Id = Guid.NewGuid(),
PersonId = personId,
Email = input.Email,
PasswordHash = Convert.ToBase64String(hash),
Salt = salt
};
var person = new Person
{
Id = personId,
UserId = user.Id,
Name = input.Name,
Email = input.Email,
LastSeen = DateTime.UtcNow,
ImageUri = input.Image
};
dbContext.Users.Add(user);
dbContext.People.Add(person);
await dbContext.SaveChangesAsync();
return(new CreateUserPayload(user, input.ClientMutationId));
}
public MessageRepository(ChatDbContext context)
{
_context = context;
}
// The return type can be changed to IEnumerable, however to support
// paging and sorting, the following parameters must be added:
// int maximumRows
// int startRowIndex
// out int totalRowCount
// string sortByExpression
public IQueryable<Message> MessagesListView_GetData()
{
var db = new ChatDbContext();
return db.Messages.OrderByDescending(b => b.CreationDate);
}
public MessageRepository(ChatDbContext chatDbContext, IRepository <User> userRepository)
{
_context = chatDbContext;
_contextUser = userRepository;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="context"></param>
public ReadMessageService(ChatDbContext context)
{
_context = context;
}
public AccountService(ChatDbContext dbContext, IUserRepository rep)
{
_dbContext = dbContext;
_rep = rep;
}
public RoomRepository(ChatDbContext context)
{
_context = context;
}
public ChatController(ILogger <ChatController> logger
, ChatDbContext dbContext)
{
_dbContext = dbContext;
_logger = logger;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="context"></param>
public ConversationService(ChatDbContext context)
{
_context = context;
}
public SettingRepository()
{
var optionsBuilder = new DbContextOptionsBuilder <ChatDbContext>();
context = new ChatDbContext(optionsBuilder.Options);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="context"></param>
public InvitedUserService(ChatDbContext context)
{
_context = context;
}
protected void Page_Load(object sender, EventArgs e)
{
this.db = new ChatDbContext();
}
public async Task <LoginPayload> LoginAsync(
LoginInput input,
[Service] ChatDbContext dbContext,
[Service] PersonByEmailDataLoader personByEmail,
[Service] ITopicEventSender eventSender,
CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(input.Email))
{
throw new QueryException(
ErrorBuilder.New()
.SetMessage("The email mustn't be empty.")
.SetCode("EMAIL_EMPTY")
.Build());
}
if (string.IsNullOrEmpty(input.Password))
{
throw new QueryException(
ErrorBuilder.New()
.SetMessage("The password mustn't be empty.")
.SetCode("PASSWORD_EMPTY")
.Build());
}
User?user = await dbContext.Users.FirstOrDefaultAsync(t => t.Email == input.Email);
if (user is null)
{
throw new QueryException(
ErrorBuilder.New()
.SetMessage("The specified username or password are invalid.")
.SetCode("INVALID_CREDENTIALS")
.Build());
}
using var sha = SHA512.Create();
byte[] hash = sha.ComputeHash(Encoding.UTF8.GetBytes(input.Password + user.Salt));
if (!Convert.ToBase64String(hash).Equals(user.PasswordHash, StringComparison.Ordinal))
{
throw new QueryException(
ErrorBuilder.New()
.SetMessage("The specified username or password are invalid.")
.SetCode("INVALID_CREDENTIALS")
.Build());
}
Person me = await personByEmail.LoadAsync(input.Email, cancellationToken);
var identity = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, user.Email),
new Claim(ClaimTypes.Email, user.Email),
new Claim(WellKnownClaimTypes.UserId, me.Id.ToString()),
});
var tokenHandler = new JwtSecurityTokenHandler();
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = identity,
Expires = DateTime.UtcNow.AddHours(12),
SigningCredentials = new SigningCredentials(
new SymmetricSecurityKey(Startup.SharedSecret),
SecurityAlgorithms.HmacSha256Signature)
};
SecurityToken token = tokenHandler.CreateToken(tokenDescriptor);
string tokenString = tokenHandler.WriteToken(token);
await eventSender.SendAsync <string, Person>("online", me);
return(new LoginPayload(me, tokenString, "bearer", input.ClientMutationId));
}
public MessageRepository(ChatDbContext dbContext)
{
_dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
}
public ChatRoomEFRepository(ChatDbContext context)
: base(context)
{
_context = context;
}
public DocumentService(ChatDbContext chatDbContext)
{
_chatDbContext = chatDbContext;
}
public ChatHub(ChatDbContext context)
{
_context = context;
}
public IQueryable <Person> GetMe(
[GlobalState] string currentUserEmail,
[Service] ChatDbContext dbContext) =>
dbContext.People.Where(t => t.Email == currentUserEmail);
public UserRepository(ChatDbContext chatDbContext)
{
_context = chatDbContext;
}
public IQueryable <Person> GetPeople(
[Service] ChatDbContext dbContext) =>
dbContext.People;
