public async Task <IActionResult> SeedDb()
{
var itemsRange = new MenuItems[]
{
new MenuItems
{
Category = "Starter",
Descrition = "Saláta csirkemellel, uborkával, pirított kenyérkockával",
Name = "Cézár saláta",
Price = 700,
Spicy = 0,
Vegetarian = 0
},
new MenuItems
{
Category = "Drink",
Descrition = null,
Name = "Coca cola",
Price = 300,
Spicy = null,
Vegetarian = null
}
};
_ctx.menuItems.AddRange(itemsRange);
await _ctx.SaveChangesAsync();
return(Ok(await _ctx.menuItems.ToListAsync()));
}
public async Task <IActionResult> PutValue(int id, Value value)
{
if (id != value.Id)
{
return(BadRequest());
}
_context.Entry(value).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ValueExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <BlogComments> Add(BlogComments blogComment)
{
await _context.BlogComments.AddAsync(blogComment);
await _context.SaveChangesAsync();
return(blogComment);
}
public async Task <Blogs> Add(Blogs blog)
{
await _context.Blogs.AddAsync(blog);
await _context.SaveChangesAsync();
return(blog);
}
public async Task <ActionResult> Create([Bind("Id, Firstname, Lastname, Age, Email, Gender, SexualOrientation, Active, ImageFile")] Profile profile)
{
if (ModelState.IsValid)
{
try
{
var pic = profile.ImageFile;
if (pic == null)
{
profile.ImagePath = "StandardProfil.png";
}
else
{
string wwwRootPath = _hostEnvironment.WebRootPath;
string filename = Path.GetFileNameWithoutExtension(profile.ImageFile.FileName);
string extension = Path.GetExtension(profile.ImageFile.FileName);
profile.ImagePath = filename = filename + DateTime.Now.ToString("yymmssfff") + extension;
string path = Path.Combine(wwwRootPath + "/Image", filename);
using (var fileStream = new FileStream(path, FileMode.Create))
{
await profile.ImageFile.CopyToAsync(fileStream);
}
}
_DatingContext.Profiles.Add(new DataLayer.Models.Profile
{
Firstname = profile.Firstname,
Lastname = profile.Lastname,
Gender = profile.Gender,
Active = true,
Age = profile.Age,
Email = User.Identity.Name.ToString(),
SexualOrientation = profile.SexualOrientation,
ImagePath = profile.ImagePath
});
await _DatingContext.SaveChangesAsync();
return(RedirectToAction("index", "Wall"));
}
catch
{
return(RedirectToAction(nameof(Index)));
}
}
else
{
return(View());
}
}
public async Task <UserModel> Register(UserModel user, string password)
{
(var hashedPassowrd, var passowrdSalt) = GeneratePassowrdHashWithSalt(password);
user.PasswordHash = hashedPassowrd;
user.PasswordSalt = passowrdSalt;
await _contex.Users.AddAsync(user);
await _contex.SaveChangesAsync();
return(user);
}
public async Task SendMessage([FromBody] Message message)
{
int user = _DatingContext.Profiles.SingleOrDefault(p => p.Email == User.Identity.Name).Id;
DataLayer.Models.Message databaseMessage = new DataLayer.Models.Message()
{
SenderId = user,
ReceiverId = message.ReceiverId,
Text = message.Text,
Date = DateTime.Now
};
_DatingContext.Messages.Add(databaseMessage);
await _DatingContext.SaveChangesAsync();
}
private async Task WebSocketRequest(AspNetWebSocketContext context)
{
var socket = context.WebSocket;
int id = 0;
while (true)
{
var buffer = new ArraySegment <byte>(new byte[64]);
var result = await socket.ReceiveAsync(buffer, CancellationToken.None);//При подключенном сокете сообщения не приходит, при разрыве приходит массив нулей
byte[] cleanBuffer = buffer.Array.Where(b => b != 0).ToArray();
if (cleanBuffer.Length > 0)
{
id = Convert.ToInt32(Encoding.UTF8.GetString(buffer.Array));
if (!Clients.ContainsKey(id))//Исключаем дублирование сокета клиента
{
Clients.Add(id, socket);
using (DatingContext db = new DatingContext())
{
SiteUser user = db.SiteUsers.FirstOrDefault(x => x.id == id);
user.online = true;
await db.SaveChangesAsync();
}
}
}
try
{
if (socket.State == WebSocketState.CloseReceived)
{
using (DatingContext db = new DatingContext())
{
SiteUser user = db.SiteUsers.FirstOrDefault(x => x.id == id);
user.online = false;
await db.SaveChangesAsync();
}
Clients.Remove(id);
}
}
catch (ObjectDisposedException)
{
using (DatingContext db = new DatingContext())
{
SiteUser user = db.SiteUsers.FirstOrDefault(x => x.id == id);
user.online = false;
await db.SaveChangesAsync();
}
Clients.Remove(id);
}
}
}
public async Task <User> Regiter(User user, string password)
{
byte[] passwordHash, passwordSalt;
CreatePasswordHash(password, out passwordHash, out passwordSalt);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
await _context.users.AddAsync(user);
await _context.SaveChangesAsync();
return(user);
}
async Task <UserDto> IRequestHandler <RegisterUserCommand, UserDto> .Handle(RegisterUserCommand request, CancellationToken cancellationToken)
{
byte[] passwordHash;
byte[] passwordSalt;
CreatePasswordHash(request.Password, out passwordHash, out passwordSalt);
var user = new User
{
UserName = request.UserName,
State = UserState.Registered,
PasswordHash = passwordHash,
PasswordSalt = passwordSalt
};
context.Users.Add(user);
await context.SaveChangesAsync();
return(new UserDto {
UserName = request.UserName
});
}
public async Task <Users> Register(Users user, string password)
{
try
{
byte[] passwordHash, passwordSalt;
CreatePasswordHash(password, out passwordHash, out passwordSalt);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
await _context.Users.AddAsync(user);
await _context.SaveChangesAsync();
return(user);
}
catch (Exception ex)
{
string str = ex.Message;
return(null);
}
}
private async Task WebSocketRequest(AspNetWebSocketContext context)
{
WebSocket clientSocket = context.WebSocket;
var buffer = new ArraySegment <byte>(new byte[1024]);
var result = await clientSocket.ReceiveAsync(buffer, CancellationToken.None);
byte[] cleanBuffer = buffer.Array.Where(b => b != 0).ToArray();//Чистим массив от пустых байтов, чтобы он не содержал мусор
int id = 0;
if (cleanBuffer.Length > 0)
{
id = Convert.ToInt32(Encoding.UTF8.GetString(buffer.Array));
}
if (!users.ContainsKey(id))//Если в списке диалогов(подключенных клиентов) уже есть клиент, добавляем его(или их)
{
users.Add(id, clientSocket);
}
while (true)
{
result = await clientSocket.ReceiveAsync(buffer, CancellationToken.None);
if (clientSocket.State != WebSocketState.Open)
{
users.Remove(id);
}
cleanBuffer = buffer.Array.Where(b => b != 0).ToArray();
string json = Encoding.UTF8.GetString(cleanBuffer);
LikeList like = JsonConvert.DeserializeObject <LikeList>(json);
using (DatingContext db = new DatingContext())
{
string action;
//LikeList likeExists = db.LikeList.FirstOrDefault(x => (x.from == like.from && x.to == like.to) || (x.from == like.to && x.to == like.from));
LikeList likeExists = db.LikeList.FirstOrDefault(x => x.from == like.from && x.to == like.to);
if (likeExists != null)
{
like = likeExists;
db.LikeList.Remove(likeExists);
action = "Remove";
}
else
{
db.LikeList.Add(like);
action = "Add";
}
await db.SaveChangesAsync();
if (users.ContainsKey(like.to))
{
WebSocket ws = users[like.to];
object response = new { like, action };
json = JsonConvert.SerializeObject(response);
cleanBuffer = Encoding.UTF8.GetBytes(json);
await users[id].SendAsync(new ArraySegment <byte>(cleanBuffer), WebSocketMessageType.Text, true, CancellationToken.None);
if (ws.State == WebSocketState.Open)
{
await ws.SendAsync(new ArraySegment <byte>(cleanBuffer), WebSocketMessageType.Text, true, CancellationToken.None);
}
}
}
}
}
private async Task SaveChanges()
{
await _datingContext.SaveChangesAsync();
}
private async Task WebSocketRequest(AspNetWebSocketContext context)
{
// Получаем сокет клиента из контекста запроса
var socket = context.WebSocket;
// Слушаем его
while (true)
{
var buffer = new ArraySegment <byte>(new byte[1024]);
// Ожидаем данные от него
var result = await socket.ReceiveAsync(buffer, CancellationToken.None);
//Десериализуем пришедший массив баййтов в строку json, а далее записываем его в объект Dialog
//сохраняем его в базу
byte[] cleanBuffer = buffer.Array.Where(b => b != 0).ToArray();//Чистим массив от пустых битов, чтобы он не содержал мусор
string json = Encoding.UTF8.GetString(cleanBuffer);
Dialog authDate = JsonConvert.DeserializeObject <Dialog>(json);
authDate.time = DateTime.Now;
using (DatingContext db = new DatingContext())
{
db.Dialogs.Add(authDate);
await db.SaveChangesAsync();
}
json = JsonConvert.SerializeObject(authDate);
cleanBuffer = Encoding.UTF8.GetBytes(json);
List <WebSocket> dialogClients = new List <WebSocket>();
if (Dialogs.ContainsKey(authDate.dialogId))//Если в списке диалогов(подключенных клиентов) уже есть клиент, добавляем его(или их)
{
dialogClients = Dialogs[authDate.dialogId];
}
{
if (!Dialogs.ContainsKey(authDate.dialogId))
{
dialogClients.Add(socket);
Dialogs.Add(authDate.dialogId, dialogClients);
}
else if (Dialogs[authDate.dialogId].FirstOrDefault(x => x == socket) == null)//Исключаем дублирование сокета 1-го клиента
{
dialogClients.Add(socket);
Dialogs[authDate.dialogId] = dialogClients;
}
}
for (int i = 0; i < dialogClients.Count(); i++)
{
WebSocket client = dialogClients[i];
try
{
if (client.State == WebSocketState.Open)
{
await client.SendAsync(new ArraySegment <byte>(cleanBuffer), WebSocketMessageType.Text, true, CancellationToken.None);
}
}
catch (ObjectDisposedException)
{
Dialogs[authDate.dialogId].Remove(client);
i--;
}
}
}
}
public async Task <bool> SaveAll()
{
return(await _context.SaveChangesAsync() > 0);
}
private async Task WebSocketRequest(AspNetWebSocketContext context)
{
WebSocket clientSocket = context.WebSocket;
var buffer = new ArraySegment <byte>(new byte[1024]);
var result = await clientSocket.ReceiveAsync(buffer, CancellationToken.None);
byte[] cleanBuffer = buffer.Array.Where(b => b != 0).ToArray();//Чистим массив от пустых байтов, чтобы он не содержал мусор
int id = 0;
if (cleanBuffer.Length > 0)
{
id = Convert.ToInt32(Encoding.UTF8.GetString(buffer.Array));
}
if (!users.ContainsKey(id))//Если в списке диалогов(подключенных клиентов) уже есть клиент, добавляем его(или их)
{
users.Add(id, clientSocket);
}
while (true)
{
result = await clientSocket.ReceiveAsync(buffer, CancellationToken.None);
if (clientSocket.State != WebSocketState.Open)
{
users.Remove(id);
}
cleanBuffer = buffer.Array.Where(b => b != 0).ToArray();
string json = Encoding.UTF8.GetString(cleanBuffer);
GuestList guest = JsonConvert.DeserializeObject <GuestList>(json);
guest.lastVisit = DateTime.Now;
using (DatingContext db = new DatingContext())
{
//LikeList likeExists = db.LikeList.FirstOrDefault(x => (x.from == like.from && x.to == like.to) || (x.from == like.to && x.to == like.from));
GuestList guestExists = db.Guests.FirstOrDefault(x => x.who == guest.who &&
x.to == guest.to);
if ((guest.lastVisit - guestExists.lastVisit).Minutes >= GuestListsController.guestExpire)
{
if (guestExists != null)
{
guest = guestExists;
guest.count++;
guest.lastVisit = DateTime.Now;
db.Entry(guest).State = System.Data.Entity.EntityState.Modified;
}
else
{
guest.count = 1;
db.Guests.Add(guest);
}
await db.SaveChangesAsync();
if (users.ContainsKey(guest.to))
{
WebSocket ws = users[guest.to];
json = JsonConvert.SerializeObject(guest);
cleanBuffer = Encoding.UTF8.GetBytes(json);
await users[id].SendAsync(new ArraySegment <byte>(cleanBuffer), WebSocketMessageType.Text, true, CancellationToken.None);
if (ws.State == WebSocketState.Open)
{
await ws.SendAsync(new ArraySegment <byte>(cleanBuffer), WebSocketMessageType.Text, true, CancellationToken.None);
}
}
}
}
}
}