public OutputSocketMessageWithUsers Execute(object val, string myLogin, Guid actId)
{
#region Тестовые данные
/* {
* "execFun": "GetDialogs",
* "data": {
* "msgCount": "2"
* }
* }
*/
#endregion
OutputSocketMessage output = new OutputSocketMessage("getMsg", actId, true, "", new { });
OutputSocketMessageWithUsers rez = new OutputSocketMessageWithUsers();
GetDialogsInfo info = DeserializeObject.ParseJSON <GetDialogsInfo>(val, output, out rez);
if (info == null)
{
return(rez);
}
using (var db = new RaidaContext())
{
Members owner = db.Members.First(it => it.login.Equals(myLogin));
// ReSharper disable once SuggestVarOrType_Elsewhere
List <OutGetMsgInfo> list = new List <OutGetMsgInfo>();
//I'am consist in this dialogs
List <MemberInGroup> mg = db.MemberInGroup.Include(g => g.group)
.ThenInclude(s => s.Shares).ThenInclude(own => own.owner)
.Where(it => it.member.login.Equals(myLogin))
.ToList();
mg.ForEach(it => {
string groupName = it.group.group_name_part;
if (it.group.one_to_one)
{
groupName = db.MemberInGroup.Include(m => m.member).FirstOrDefault(mig => mig.group == it.group && mig.member != owner)?.member.nick_name;
}
OutGetMsgInfo group = new OutGetMsgInfo(it.group.group_id, groupName, it.group.one_to_one, it.group.privated);
//Add all message in dialog
it.group.Shares.OrderBy(s => s.sending_date)
.Take(info.msgCount)
.ToList()
.ForEach(msg => group.messages.Add(new OneMessageInfo(msg.id, Encoding.Unicode.GetString(msg.file_data), msg.current_fragment, msg.total_fragment, msg.sending_date, msg.owner.nick_name, msg.owner.login)));
//Add users where consist in dialog
db.MemberInGroup.Include(m => m.member).Where(mig => mig.groupId.Equals(it.groupId))
.ForEachAsync(memb => group.members.Add(memb.member.login));
list.Add(group);
});
output.data = list;
}
rez.msgForOwner = output;
return(rez);
}
public OutputSocketMessageWithUsers Execute(object val, string myLogin, Guid actId)
{
#region Тестовые данные
/* {
* "execFun": "OrganizationAddMember",
* "data": {
* "login": "******",
* "password": "******",
* "nickName": "Serj",
* "transactionId": "80f7efc032cd4a2c97f89fca11ad3701"
* }
* }
*/
#endregion
OutputSocketMessage output = new OutputSocketMessage("OrganizationAddMember", actId, true, "", new { });
OutputSocketMessageWithUsers rez = new OutputSocketMessageWithUsers();
using (var db = new RaidaContext())
{
Members owner = db.Members.Include(o => o.organization).First(it => it.login.Equals(myLogin));
if (owner.organization != null && owner.organization.owner == owner)
{
Registration registration = new Registration();
rez = registration.Execute(val, myLogin, actId);
rez.msgForOwner.callFunction = "OrganizationAddMember";
if (rez.msgForOwner.success)
{
try
{
RegistrationInfo info = DeserializeObject.ParseJSON <RegistrationInfo>(val, output, out rez);
Organizations organization = db.Organizations.Include(m => m.members).First(it => it == owner.organization);
Members newMember = db.Members.First(it => it.login.Equals(info.login.Trim(), StringComparison.CurrentCultureIgnoreCase));
newMember.organization = organization;
organization.members.Add(newMember);
db.SaveChanges();
output.data = new { newMember.login, nickName = newMember.nick_name };
rez.msgForOwner = output;
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
else
{
output.success = false;
output.msgError = "You a not consist in organization or a not organization owner";
rez.msgForOwner = output;
}
}
return(rez);
}
public OutputSocketMessageWithUsers Execute(object val, string myLogin, Guid actId)
{
#region Тестовые данные
/* {
* "execFun": "GetMsg",
* "data": {
* "dialogId": "788FEFAD0ED24436AD73D968685110E8",
* "msgCount": "2",
* "offset": "0"
* }
* }
*/
#endregion
OutputSocketMessage output = new OutputSocketMessage("getMsg", actId, true, "", new { });
OutputSocketMessageWithUsers rez = new OutputSocketMessageWithUsers();
GetMsgInfo info = DeserializeObject.ParseJSON <GetMsgInfo>(val, output, out rez);
if (info == null)
{
return(rez);
}
using (var db = new RaidaContext())
{
Members owner = db.Members.First(it => it.login.Equals(myLogin));
if (db.MemberInGroup.Include(g => g.group).Any(it => it.member.login.Equals(myLogin) && it.groupId == info.dialogId))
{
MemberInGroup mg = db.MemberInGroup.Include(g => g.group).ThenInclude(s => s.Shares).Where(it => it.member.login.Equals(myLogin) && it.groupId == info.dialogId).First();
string groupName = mg.group.group_name_part;
if (mg.group.one_to_one)
{
groupName = db.MemberInGroup.Include(m => m.member).FirstOrDefault(mig => mig.group == mg.group && mig.member != owner)?.member.nick_name;
}
OutGetMsgInfo groupMsg = new OutGetMsgInfo(mg.group.group_id, groupName, mg.group.one_to_one, mg.group.privated);
mg.group.Shares.Where(it => it.death_date > SystemClock.GetInstance().CurrentTime)
.OrderBy(s => s.sending_date)
.Skip(info.offset)
.Take(info.msgCount)
.ToList()
.ForEach(msg => groupMsg.messages.Add(new OneMessageInfo(msg.id, Encoding.Unicode.GetString(msg.file_data), msg.current_fragment, msg.total_fragment, msg.sending_date, msg.owner.nick_name, msg.owner.login)));
output.data = groupMsg;
}
else
{
output.success = false;
output.msgError = "Dialog is not found";
}
}
rez.msgForOwner = output;
return(rez);
}
public OutputSocketMessageWithUsers Execute(object val, string myLogin, Guid actId)
{
#region Тестовые данные
/*
* {
* "execFun": "rollbacktransaction",
* "data": {
* "transactionId": "80f7efc032dd4a7c97f69fca51ad3001"
* }
* }
*/
#endregion
OutputSocketMessage output = new OutputSocketMessage("rollbackTransaction", actId, true, "", new { });
OutputSocketMessageWithUsers rez = new OutputSocketMessageWithUsers();
TransactionInfo info = DeserializeObject.ParseJSON <TransactionInfo>(val, output, out rez);
if (info == null)
{
return(rez);
}
Guid transId = info.transactionId;
output.data = new { transactionId = transId };
//long dateNow = DateTimeOffset.Now.ToUnixTimeSeconds();
long dateNow = SystemClock.GetInstance().CurrentTime;
using (var db = new RaidaContext())
{
Members owner = db.Members.FirstOrDefault(it => it.login == myLogin);
if (!db.Transactions.Any(it => it.transactionId == transId))
{
output.success = false;
output.msgError = "This transaction is not found";
}
else if (!(db.Transactions.Any(it => it.transactionId == transId && it.owner == owner)))
{
output.success = false;
output.msgError = "You not owner for this transaction";
}
else if (!(db.Transactions.Any(it => it.transactionId == transId && it.owner == owner && it.rollbackTime > dateNow)))
{
output.success = false;
output.msgError = "This transaction is blocked";
}
else
{
Transaction.rollbackTransaction(transId, owner);
}
}
rez.msgForOwner = output;
return(rez);
}
public OutputSocketMessageWithUsers Execute(object val, string myLogin, Guid actId)
{
#region Тестовые данные
/*
* {
* "execFun": "SetDialogPrivate",
* "data": {
* "publicId": "18A0CA0657DE4FB09CDC86008B2A8EBE",
* "privated": "false"
* }
* }
*/
#endregion
OutputSocketMessage output = new OutputSocketMessage("SetDialogPrivate", actId, true, "", new { });
OutputSocketMessageWithUsers rez = new OutputSocketMessageWithUsers();
SetDialogPrivateInfo info = DeserializeObject.ParseJSON <SetDialogPrivateInfo>(val, output, out rez);
if (info == null)
{
return(rez);
}
using (var db = new RaidaContext())
{
Members owner = db.Members.First(it => it.login.Equals(myLogin));
if (db.Groups.Any(it => it.group_id == info.publicId && it.owner == owner))
{
Groups group = db.Groups.First(it => it.group_id == info.publicId && it.owner == owner);
group.privated = info.privated;
db.SaveChanges();
output.data = new { dialogId = group.group_id, group.privated };
List <MemberInGroup> membersInGroup = db.MemberInGroup.Include(m => m.member).Where(it => it.group == group && it.member != owner).ToList();
membersInGroup.ForEach(it => rez.forUserLogin.Add(it.member.login));
rez.msgForOther = output;
}
else
{
output.success = false;
output.msgError = "This dialog not found or you not owner";
rez.msgForOwner = output;
return(rez);
}
}
rez.msgForOwner = output;
return(rez);
}
/* { "execFun": "registration",
* "data": {
* "login": "******",
* "password": "******",
* "nickName": "gosha",
* "transactionId": "80f7efc032dd4a7c97f69fca51ad3001"
* }
* }
*/
public OutputSocketMessageWithUsers Execute(object val, string myLogin, Guid actId)
{
OutputSocketMessage output = new OutputSocketMessage("registration", actId, true, "", new { });
OutputSocketMessageWithUsers rez = new OutputSocketMessageWithUsers();
RegistrationInfo info = DeserializeObject.ParseJSON <RegistrationInfo>(val, output, out rez);
if (info == null)
{
return(rez);
}
using (var db = new RaidaContext())
{
if (db.Members.Any(it => it.login.Equals(info.login.Trim(), StringComparison.CurrentCultureIgnoreCase)))
{
output.success = false;
output.msgError = "This login already exists";
}
else
{
Guid privateId = Guid.NewGuid();
while (db.Members.Any(it => it.private_id == privateId))
{
privateId = Guid.NewGuid();
}
info.password = Argon2.Hash(info.password, 1, 512, 8); //Hashing password
Members member = new Members
{
private_id = privateId,
login = info.login.Trim().ToLower(),
pass = info.password,
nick_name = info.nickName,
last_use = SystemClock.GetInstance().CurrentTime,
description_fragment = "",
photo_fragment = "",
kb_bandwidth_used = 0,
online = false,
};
db.Members.Add(member);
Transaction.saveTransaction(db, info.transactionId, Transaction.TABLE_NAME.MEMBERS, privateId.ToString(), member);
db.SaveChanges();
}
}
rez.msgForOwner = output;
return(rez);
}
/// <summary>
/// Проверка и преобразование входных параметров метода
/// </summary>
/// <typeparam name="T">Ожидаемый класс</typeparam>
/// <param name="data">Объект с проверяемыми данными</param>
/// <param name="outp">Отображаемое сообщение</param>
/// <param name="rez">Общий клас объект для возврата данных</param>
/// <returns>Объект класса Т</returns>
private T DeserObj <T>(Object data, OutputSocketMessage outp, out OutputSocketMessageWithUsers rez)
{
rez = new OutputSocketMessageWithUsers();
T sucObj = default(T);
try
{
sucObj = JsonConvert.DeserializeObject <T>(data.ToString());
}
catch
{
outp.success = false;
outp.msgError = "Invalid sending data";
rez.msgForOwner = outp;
}
return(sucObj);
}
//Работает
private OutputSocketMessageWithUsers getmydialogs(Object val, Guid myPublicLogin)
{
#region Тестовые данные
/*
* {
* "execFun": "getMyDialogs",
* "data": {}
* }
*/
#endregion
OutputSocketMessage output = new OutputSocketMessage("getMyDialogs", true, "", new { });
OutputSocketMessageWithUsers rez = new OutputSocketMessageWithUsers();
using (var db = new CloudChatEntities()) {
var data = db.group_members.Where(it => it.member_id == db.members.Where(i => i.public_id == myPublicLogin).FirstOrDefault().private_id)
.Select(u => new
{
id = u.group_id,
name = u.groups.group_name_part,
group = true
}).ToList();
Guid myPrivateId = db.members.Where(t => t.public_id == myPublicLogin).FirstOrDefault().private_id;
data.AddRange(db.shares.Where(it => it.self_one_or_group.ToLower() == "false" && (it.to_public == myPublicLogin || it.owner_private == myPrivateId))
.Select(u => new
{
id = u.to_public == myPublicLogin ? db.members.Where(m => m.private_id == u.owner_private).FirstOrDefault().public_id : u.to_public,
name = u.to_public == myPublicLogin ? db.members.Where(m => m.private_id == u.owner_private).FirstOrDefault().login : db.members.Where(m => m.public_id == u.to_public).FirstOrDefault().login,
group = false
})
.Distinct()
.ToList()
);
output.data = data;
}
rez.msgForOwner = output;
return(rez);
}
public OutputSocketMessageWithUsers Execute(object val, string myLogin, Guid actId)
{
#region Тестовые данные
/* {
* "execFun": "GetUsers",
* "data": { }
* }
*/
#endregion
OutputSocketMessage output = new OutputSocketMessage("getUsersInfo", actId, true, "", new { });
OutputSocketMessageWithUsers rez = new OutputSocketMessageWithUsers();
using (var db = new RaidaContext())
{
List <MemberInGroup> mg = db.MemberInGroup.Include(g => g.group)
.ThenInclude(own => own.owner)
.Where(it => it.member.login.Equals(myLogin))
.ToList();
List <UserInfo> users = new List <UserInfo>();
mg.ForEach(it => {
db.MemberInGroup.Include(m => m.member).Where(mig => mig.groupId.Equals(it.groupId))
.ForEachAsync(memb =>
{
users.Add(new UserInfo(
memb.member.login,
memb.member.nick_name,
memb.member.photo_fragment.ToString(),
memb.member.online));
});
});
users = users.Distinct().ToList();
output.data = users;
}
rez.msgForOwner = output;
return(rez);
}
//Работает
private OutputSocketMessageWithUsers registration(Object val, Object nothing)
{
#region Тестовые данные
/*
* {
* "execFun": "registration",
* "data": {
* "login": "******",
* "an": "d842703c8acb4bd893876d700f60683e",
* "publicId": "80f7efc032dd4a7c97f69fca51ad3000"
* }
* }
*/
#endregion
OutputSocketMessage output = new OutputSocketMessage("registration", true, "", new { });
OutputSocketMessageWithUsers rez = new OutputSocketMessageWithUsers();
RegistrationInfo info = DeserObj <RegistrationInfo>(val, output, out rez);
if (info == null)
{
return(rez);
}
using (var db = new CloudChatEntities())
{
if (db.members.Any(it => it.login.Equals(info.login.Trim(), StringComparison.CurrentCultureIgnoreCase)))
{
output.success = false;
output.msgError = "This login already exists";
}
else
{
db.usp_membersInsert(info.login.Trim(), info.publicId, info.an, Guid.NewGuid(), DateTime.Now, Guid.NewGuid(), "", new byte[5], 0, "redy");
}
}
rez.msgForOwner = output;
return(rez);
}
public static T ParseJSON <T> (object json, OutputSocketMessage outp, out OutputSocketMessageWithUsers rez)
{
rez = new OutputSocketMessageWithUsers();
T sucObj = default(T);
try
{
var settings = new JsonSerializerSettings
{
MissingMemberHandling = MissingMemberHandling.Error
};
sucObj = JsonConvert.DeserializeObject <T>(json.ToString(), settings);
}
catch
{
outp.success = false;
outp.msgError = "Invalid sending data";
rez.msgForOwner = outp;
}
return(sucObj);
}
//Работает
private OutputSocketMessageWithUsers creategroup(Object val, Guid myPublicLogin)
{
#region Тестовые данные
/*
* {
* "execFun": "createGroup",
* "data": {
* "groupName": "MeCloseGroup",
* "public_id": "48A0CA0657DE4FB09CDC86008B2A8EBE"
* }
* }
*/
#endregion
OutputSocketMessage output = new OutputSocketMessage("createGroup", true, "", new { });
OutputSocketMessageWithUsers rez = new OutputSocketMessageWithUsers();
GroupInfo info = DeserObj <GroupInfo>(val, output, out rez);
if (info == null)
{
return(rez);
}
using (var db = new CloudChatEntities())
{
Guid owner = db.usp_membersSelect(myPublicLogin).First().private_id;
db.usp_groupsInsert(info.public_id, info.name, owner, "", Guid.Empty);
db.usp_group_membersInsert(info.public_id, owner, "allow_or_deny");
}
output.data = new { id = info.public_id, name = info.name };
rez.msgForOwner = output;
//rez.usersId.Add(info.login);
return(rez);
}
private OutputSocketMessageWithUsers getmsg(Object val, Guid myPublicLogin)
{
#region Тестовые данные
/*
* {
* "execFun": "getMsg",
* "data": {
* "getAll": "true",
* "onGroup": "false",
* "onlyId": "00000000000000000000000000000000"
* }
* }
*
* {
* "execFun": "getMsg",
* "data": {
* "getAll": "false",
* "onGroup": "true",
* "onlyId": "48A0CA0657DE4FB09CDC86008B2A8EBE"
* }
* }
* {
* "execFun": "getMsg",
* "data": {
* "getAll": "false",
* "onGroup": "false",
* "onlyId": "788FEFAD0ED24436AD73D968685110E8"
* }
* }
*/
#endregion
OutputSocketMessage output = new OutputSocketMessage("getMsg", true, "", new { });
OutputSocketMessageWithUsers rez = new OutputSocketMessageWithUsers();
InGetMsgInfo info = DeserObj <InGetMsgInfo>(val, output, out rez);
if (info == null)
{
return(rez);
}
using (var db = new CloudChatEntities())
{
List <OutGetMsgInfo> list = new List <OutGetMsgInfo>();
var owner = db.usp_membersSelect(myPublicLogin).Single();
var myListGroupId = from m in db.members
join membgr in db.group_members on m.private_id equals membgr.member_id
//join gr in db.groups on membgr.group_id equals gr.group_id
where m.public_id == owner.public_id
select membgr.group_id;
if (info.getAll)
{
var msgInfoList = from s in db.shares
join content in db.content_over_8000 on s.id equals content.shar_id
join groupp in db.groups on s.to_public equals groupp.group_id into gs
from groupp in gs.DefaultIfEmpty()
where s.owner_private == owner.private_id ||
(s.to_public == owner.public_id && s.self_one_or_group.Equals("false", StringComparison.InvariantCultureIgnoreCase)) ||
(myListGroupId.Contains(s.to_public) && s.self_one_or_group.Equals("true", StringComparison.InvariantCultureIgnoreCase))
orderby s.sending_date descending
select new
{
guidMsg = s.id,
textMsg = content.file_data,
sender = s.owner_private,
gr = s.self_one_or_group,
recip = s.to_public,
time = s.sending_date,
cur = s.current_fragment,
total = s.total_fragment,
grName = groupp.group_name_part,
login = db.members.FirstOrDefault(it => it.private_id == s.owner_private).login
};
foreach (var item in msgInfoList)
{
string senderName = Boolean.Parse(item.gr) ? item.grName : item.login;
list.Add(
new OutGetMsgInfo(
item.guidMsg,
Encoding.Unicode.GetString(item.textMsg),
db.members.First(it => it.private_id == item.sender).public_id,
item.gr,
item.recip,
item.time,
item.cur,
item.total,
item.login,
item.grName
)
);
}
}
else
{
if (info.onGroup)
{
if (!db.groups.Any(it => it.group_id == info.onlyId) && !myListGroupId.Contains(info.onlyId))
{
output.success = false;
output.msgError = "Group is not found";
rez.msgForOwner = output;
return(rez);
}
else
{
var msgInfoList = from s in db.shares
join content in db.content_over_8000 on s.id equals content.shar_id
where (s.to_public == info.onlyId && s.self_one_or_group.Equals("true", StringComparison.InvariantCultureIgnoreCase))
orderby s.sending_date descending
select new
{
guidMsg = s.id,
textMsg = content.file_data,
sender = s.owner_private,
gr = s.self_one_or_group,
recip = s.to_public,
time = s.sending_date,
cur = s.current_fragment,
total = s.total_fragment,
login = db.members.FirstOrDefault(it => it.private_id == s.owner_private).login
};
foreach (var item in msgInfoList)
{
list.Add(
new OutGetMsgInfo(
item.guidMsg,
Encoding.Unicode.GetString(item.textMsg),
db.members.First(it => it.private_id == item.sender).public_id,
item.gr,
item.recip,
item.time,
item.cur,
item.total,
item.login,
item.login
)
);
}
}
}
else if (!db.members.Any(it => it.public_id == info.onlyId))
{
output.success = false;
output.msgError = "User is not found";
rez.msgForOwner = output;
return(rez);
}
else
{
var msgInfoList = from s in db.shares
join content in db.content_over_8000 on s.id equals content.shar_id
where (s.owner_private == owner.private_id && s.to_public == info.onlyId && s.self_one_or_group.Equals("false", StringComparison.InvariantCultureIgnoreCase)) ||
(s.owner_private == db.members.FirstOrDefault(it => it.public_id == info.onlyId).private_id&& s.to_public == owner.public_id && s.self_one_or_group.Equals("false", StringComparison.InvariantCultureIgnoreCase))
orderby s.sending_date descending
select new
{
guidMsg = s.id,
textMsg = content.file_data,
sender = s.owner_private,
gr = s.self_one_or_group,
recip = s.to_public,
time = s.sending_date,
cur = s.current_fragment,
total = s.total_fragment,
login = db.members.FirstOrDefault(it => it.private_id == s.owner_private).login
};
foreach (var item in msgInfoList)
{
list.Add(
new OutGetMsgInfo(
item.guidMsg,
Encoding.Unicode.GetString(item.textMsg),
db.members.First(it => it.private_id == item.sender).public_id,
item.gr,
item.recip,
item.time,
item.cur,
item.total,
item.login,
item.login
)
);
}
}
}
output.data = list;
}
rez.msgForOwner = output;
//rez.usersId.Add(info.login);
return(rez);
}
private OutputSocketMessageWithUsers sendmsg(Object val, Guid myPublicLogin)
{
#region Тестовые данные
/*
* {
* "execFun": "sendMsg",
* "data": {
* "recipientId": "788FEFAD0ED24436AD73D968685110E8",
* "recipientLogin": "******",
* "toGroup": "false",
* "textMsg": "test message for one user",
* "guidMsg": "91D8333FA55B40AFB46CA63E214C93C8",
* "sendTime": "1511450497620",
* "curFrg":"1",
* "totalFrg":"2"
* }
* }
*
* {
* "execFun": "sendMsg",
* "data": {
* "recipientId": "48A0CA0657DE4FB09CDC86008B2A8EBE",
* "toGroup": "true",
* "textMsg": "test message for group",
* "guidMsg": "CA5BBD6B488941FEACFA19692D3087E0",
* "sendTime": "1511450497620",
* "curFrg":"1",
* "totalFrg":"2"
* }
* }
* {
* "execFun": "sendMsg",
* "data": {
* "recipientId": "80f7efc032dd4a7c97f69fca51ad3000",
* "toGroup": "false",
* "textMsg": "response fo test message",
* "guidMsg": "19D2B66BB477467ABAE72AC79F5A2C48",
* "sendTime": "1511450497620",
* "curFrg":"1",
* "totalFrg":"2"
* }
* }
* {
* "execFun": "sendMsg",
* "data": {
* "recipientId": "48A0CA0657DE4FB09CDC86008B2A8EBE",
* "toGroup": "true",
* "textMsg": "response for group test message",
* "guidMsg": "3D45AF8702CA4857A03D7EBD90D95C89",
* "sendTime": "1511450497620",
* "curFrg":"1",
* "totalFrg":"2"
* }
* }
*/
#endregion
OutputSocketMessage output = new OutputSocketMessage("sendMsg", true, "", new { });
OutputSocketMessageWithUsers rez = new OutputSocketMessageWithUsers();
OutGetMsgInfo outputForOther = null;
InputMsgInfo info = DeserObj <InputMsgInfo>(val, output, out rez);
if (info == null)
{
return(rez);
}
using (var db = new CloudChatEntities())
{
Guid recepId = info.recipientId;
if (info.toGroup)
{
if (!db.groups.Any(it => it.group_id == info.recipientId))
{
output.success = false;
output.msgError = "Group is not found";
rez.msgForOwner = output;
return(rez);
}
}
else
{
if (!db.members.Any(it => it.public_id == info.recipientId || it.login.Equals(info.recipientLogin.Trim(), StringComparison.CurrentCultureIgnoreCase)))
{
output.success = false;
output.msgError = "User is not found";
rez.msgForOwner = output;
return(rez);
}
recepId = db.members.FirstOrDefault(it => it.public_id == info.recipientId || it.login.Equals(info.recipientLogin.Trim(), StringComparison.CurrentCultureIgnoreCase)).public_id;
}
if (output.success)
{
content_over_8000 msg = new content_over_8000();
msg.shar_id = info.msgId;
msg.file_data = Encoding.Unicode.GetBytes(info.textMsg);
db.content_over_8000.Add(msg);
shares newShare = new shares();
newShare.id = info.msgId;
newShare.owner_private = db.usp_membersSelect(myPublicLogin).First().private_id;
newShare.to_public = recepId;
newShare.self_one_or_group = info.toGroup.ToString();
newShare.content = msg;
newShare.current_fragment = info.curFrg;
newShare.total_fragment = info.totalFrg;
newShare.sending_date = info.sendTime;
newShare.file_extention = "none";
db.shares.Add(newShare);
db.SaveChanges();
string groupName = "";
if (info.toGroup)
{
groupName = db.groups.Where(it => it.group_id == recepId).FirstOrDefault().group_name_part;
}
else
{
groupName = db.members.FirstOrDefault(it => it.public_id == recepId).login;
}
string login = db.members.FirstOrDefault(it => it.private_id == newShare.owner_private).login;
outputForOther = new OutGetMsgInfo(info.msgId, info.textMsg, myPublicLogin, info.toGroup.ToString(), recepId, info.sendTime, info.curFrg, info.totalFrg, login, groupName);
if (info.toGroup)
{
db.group_members.Where(it => it.group_id == recepId && it.member_id != newShare.owner_private)
.ToList()
.ForEach(it => rez.usersId.Add(
db.members.First(m => m.private_id == it.member_id).public_id
)
);
}
else
{
//rez.usersId.Add(info.login);
rez.usersId.Add(recepId);
}
}
}
output.data = outputForOther;
rez.msgForOwner = output;
rez.msgForOther = output;
// rez.msgForOther = new { callFunction="newMessage", data = outputForOther } ;
return(rez);
}
//Работает
private OutputSocketMessageWithUsers addmemberingroup(Object val, Guid myPublicLogin)
{
#region Тестовые данные
/*
* {
* "execFun": "addMemberInGroup",
* "data": {
* "memberLogin": "******",
* "groupId": "48A0CA0657DE4FB09CDC86008B2A8EBE"
* }
* }
*/
#endregion
OutputSocketMessage output = new OutputSocketMessage("addMemberInGroup", true, "", new { });
OutputSocketMessageWithUsers rez = new OutputSocketMessageWithUsers();
AddMemberInGroupInfo info = DeserObj <AddMemberInGroupInfo>(val, output, out rez);
if (info == null)
{
return(rez);
}
using (var db = new CloudChatEntities())
{
if (db.members.Any(it => it.login.Equals(info.memberLogin.Trim(), StringComparison.CurrentCultureIgnoreCase)))
{
Guid owner = db.members.First(it => it.public_id == myPublicLogin).private_id;
if (db.group_members.Any(it => it.member_id == owner && it.group_id == info.groupId))
{
members user = db.members.FirstOrDefault(it => it.login.Equals(info.memberLogin.Trim()));
if (db.group_members.Any(it => it.group_id == info.groupId && it.member_id == user.private_id))
{
output.success = false;
output.msgError = "This user already consists in this group";
}
else
{
db.usp_group_membersInsert(info.groupId, user.private_id, "I don't known");
rez.usersId.Add(user.public_id);
rez.msgForOther = new {
callFunction = "addMemberInGroup",
id = info.groupId,
name = db.groups.Where(it => it.group_id == info.groupId).First().group_name_part
};
}
}
else
{
output.success = false;
output.msgError = "Group is not found";
}
}
else
{
output.success = false;
output.msgError = "User is not found";
}
}
rez.msgForOwner = output;
return(rez);
}
public OutputSocketMessageWithUsers Execute(object val, string myLogin, Guid actId)
{
#region Тестовые данные
/*
* {
* "execFun": "OrganizationCreate",
* "data": {
* "publicId": "788FEFAD0ED24436AD73D968685110E8",
* "name": "Organization Only One",
* "transactionId": "80f7efc092da4a1c47f69fca51ad1100"
* }
* }
*/
#endregion
OutputSocketMessage output = new OutputSocketMessage("OrganizationCreate", actId, true, "", new { });
OutputSocketMessageWithUsers rez = new OutputSocketMessageWithUsers();
OrganizationCreateInfo info = DeserializeObject.ParseJSON <OrganizationCreateInfo>(val, output, out rez);
if (info == null)
{
return(rez);
}
using (var db = new RaidaContext())
{
Members owner = db.Members.Include(o => o.organization).First(it => it.login.Equals(myLogin));
if (owner.organization == null)
{
if (!db.Organizations.Any(it => it.public_id == info.publicId))
{
Guid privateId = Guid.NewGuid();
while (db.Organizations.Any(it => it.private_id == privateId))
{
privateId = Guid.NewGuid();
}
Organizations newOrganiz = new Organizations
{
private_id = privateId,
public_id = info.publicId,
org_name_part = info.name,
kb_of_credit = 0,
owner = owner
};
newOrganiz.members.Add(owner);
db.Organizations.Add(newOrganiz);
Transaction.saveTransaction(db, info.transactionId, Transaction.TABLE_NAME.ORGANIZATIONS, newOrganiz.private_id.ToString(), owner);
db.SaveChanges();
output.data = new { publicId = newOrganiz.public_id, name = newOrganiz.org_name_part };
}
else
{
output.success = false;
output.msgError = "Change the publicId";
}
}
else
{
output.success = false;
output.msgError = "You a have already organization";
}
}
rez.msgForOwner = output;
return(rez);
}
public OutputSocketMessageWithUsers Execute(object val, string myLogin, Guid actId)
{
#region Тестовые данные
/* {
* "execFun": "ChangeUserInfo",
* "data": {
* "name":"String",
* "photo":"String",
* "about":"String",
* "changePass":"******",
* "oldPass":"******",
* "newPass":"******"
* }
* }
*/
#endregion
OutputSocketMessage output = new OutputSocketMessage("changeUserInfo", actId, true, "", new { });
OutputSocketMessage outputForOther = new OutputSocketMessage("changeUserInfo", Guid.Empty, true, "", new { });
OutputSocketMessageWithUsers rez = new OutputSocketMessageWithUsers();
DTO.ChangeUserInfo info = DeserializeObject.ParseJSON <DTO.ChangeUserInfo>(val, output, out rez);
if (info == null)
{
return(rez);
}
using (var db = new RaidaContext())
{
Members owner = db.Members.Include(m => m.MemberInGroup).FirstOrDefault(it => it.login.Equals(myLogin));
owner.nick_name = info.Name;
owner.photo_fragment = info.Photo;
owner.description_fragment = info.About;
if (info.ChangePass)
{
if (Argon2.Verify(owner.pass, info.OldPass, null))
{
if (info.NewPass.Trim().Length > 5)
{
owner.pass = Argon2.Hash(info.NewPass, 1, 512, 8);
}
else
{
output.success = false;
output.msgError = "Minimum length of password is 6 chars";
}
}
else
{
output.success = false;
output.msgError = "Current password is not valid";
}
}
db.SaveChanges();
var user = new UserInfo(owner.login, owner.nick_name, owner.photo_fragment, owner.online);
output.data = new
{
itself = true,
user
};
outputForOther.data = new
{
itself = false,
user
};
rez.forUserLogin = DeserializeObject.GetMyReferenceUser(db, owner);
}
rez.msgForOwner = output;
rez.msgForOther = outputForOther;
return(rez);
}
public OutputSocketMessageWithUsers Execute(object val, string myLogin, Guid actId)
{
#region Тестовые данные
/*
* {
* "execFun": "addMemberInGroup",
* "data": {
* "memberLogin": "******",
* "groupId": "48A0CA0657DE4FB09CDC86008B2A8EBE",
* "transactionId": "80f7efc032dd4a7c97f69fca51ad1100"
* }
* }
*/
#endregion
OutputSocketMessage output = new OutputSocketMessage("addMemberInGroup", actId, true, "", new { });
OutputSocketMessageWithUsers rez = new OutputSocketMessageWithUsers();
AddMemberInGroupInfo info = DeserializeObject.ParseJSON <AddMemberInGroupInfo>(val, output, out rez);
if (info == null)
{
return(rez);
}
using (var db = new RaidaContext())
{
if (db.Members.Any(it => it.login.Equals(info.memberLogin.Trim(), StringComparison.CurrentCultureIgnoreCase)))
{
Members owner = db.Members.First(it => it.login.Equals(myLogin));
if (db.MemberInGroup.Any(it => it.member == owner && it.groupId == info.groupId && !it.group.one_to_one))
{
Members user = db.Members.FirstOrDefault(it => it.login.Equals(info.memberLogin.Trim(), StringComparison.CurrentCultureIgnoreCase));
if (db.MemberInGroup.Any(it => it.groupId == info.groupId && it.member == user))
{
output.success = false;
output.msgError = "This user already exists in this group";
}
else
{
Groups group = db.Groups.First(it => it.group_id == info.groupId);
if (group.privated)
{
output.success = false;
output.msgError = "This group is private";
rez.msgForOwner = output;
return(rez);
}
int newId = 0;
if (db.MemberInGroup.Any())
{
newId = db.MemberInGroup.OrderByDescending(it => it.Id).FirstOrDefault().Id + 1;
}
MemberInGroup mg = new MemberInGroup
{
Id = newId,
group = group,
member = user
};
db.MemberInGroup.Add(mg);
Transaction.saveTransaction(db, info.transactionId, Transaction.TABLE_NAME.MEMBERS_IN_GROUP, mg.Id.ToString(), owner);
db.SaveChanges();
output.data = new { itself = true, newUser = new UserInfo(user.login, user.nick_name, user.photo_fragment, user.online), groupId = group.group_id };
var members = db.MemberInGroup.Include(ming => ming.member)
.Where(it => it.groupId.Equals(group.group_id)).Select(x => x.member.login).ToList(); //Logins of all users in dialog
rez.forUserLogin = members.Where(it => !it.Equals(myLogin)).ToList(); //Send all users in dialog, but not me
rez.msgForOther = new
{
callFunction = "AddMemberInGroup",
data = new {
id = info.groupId,
name = group.group_name_part,
oneToOne = group.one_to_one,
members = members,
newUser = new UserInfo(user.login, user.nick_name, user.photo_fragment, user.online)
}
};
}
}
else
{
output.success = false;
output.msgError = "Group is not found";
}
}
else
{
output.success = false;
output.msgError = "User is not found";
}
}
rez.msgForOwner = output;
return(rez);
}
public OutputSocketMessageWithUsers Execute(object val, string myLogin, Guid actId)
{
#region Тестовые данные
/*
* {
* "execFun": "createDialog",
* "data": {
* "name": "MeCloseGroup",
* "publicId": "48A0CA0657DE4FB09CDC86008B2A8EBE",
* "oneToOne": "false",
* "transactionId": "80f7efc032dd4a7c97f69fca51ad3100"
* }
* }
*/
#endregion
OutputSocketMessage output = new OutputSocketMessage("createDialog", actId, true, "", new { });
OutputSocketMessageWithUsers rez = new OutputSocketMessageWithUsers();
GroupInfo info = DeserializeObject.ParseJSON <GroupInfo>(val, output, out rez);
if (info == null)
{
return(rez);
}
using (var db = new RaidaContext())
{
if (db.Groups.Any(it => it.group_id == info.publicId))
{
output.success = false;
output.msgError = "Change the publicId";
rez.msgForOwner = output;
return(rez);
}
Members owner = db.Members.First(it => it.login.Equals(myLogin));
Groups group = new Groups
{
group_id = info.publicId,
group_name_part = info.name,
owner = owner,
photo_fragment = "",
one_to_one = info.oneToOne,
privated = false
};
int newId = 1;
if (db.MemberInGroup.Count() > 0)
{
newId = db.MemberInGroup.OrderByDescending(it => it.Id).FirstOrDefault().Id + 1;
}
if (info.oneToOne)
{
if (db.Members.Any(it => it.login.Equals(info.name.Trim().ToLower())))
{
group.group_name_part = "OneToOne";
Members rec = db.Members.First(it => it.login.Equals(info.name.Trim().ToLower()));
if (!db.MemberInGroup.Any(it => it.member == owner && db.MemberInGroup.Any(mg => mg.member == rec && it.group == mg.group && mg.group.one_to_one)))
{
MemberInGroup mg1 = new MemberInGroup
{
Id = newId,
group = group,
member = rec
};
db.MemberInGroup.Add(mg1);
Transaction.saveTransaction(db, info.transactionId, Transaction.TABLE_NAME.MEMBERS_IN_GROUP, mg1.Id.ToString(), owner);
newId++;
//rez.usersId.Add(info.login); Придумать ответ пользователю, которого добавили - а может он и не нужен
}
else
{
output.success = false;
output.msgError = "This dialog exists";
rez.msgForOwner = output;
return(rez);
}
}
else
{
output.success = false;
output.msgError = "User is not found";
rez.msgForOwner = output;
return(rez);
}
}
db.Groups.Add(group);
MemberInGroup OwnerInMg = new MemberInGroup
{
Id = newId,
group = group,
member = owner
};
db.MemberInGroup.Add(OwnerInMg);
try {
db.SaveChanges();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
Transaction.saveTransaction(db, info.transactionId, Transaction.TABLE_NAME.GROUPS, info.publicId.ToString(), owner);
Transaction.saveTransaction(db, info.transactionId, Transaction.TABLE_NAME.MEMBERS_IN_GROUP, OwnerInMg.Id.ToString(), owner);
}
output.data = new { id = info.publicId, info.name, info.oneToOne };
rez.msgForOwner = output;
return(rez);
}
private void NextProcessing(IClient fromClient, InputSocketDataInfo inputObject)
{
OutputSocketMessage outputSocket;
Type findClass = Type.GetType($"RAIDAChatNode.Reflections.{inputObject.execFun}", false, true);
if (findClass != null)
{
if (findClass.Equals(typeof(Authorization)))
{
AuthSocketInfo info = new Authorization().Execute(inputObject.data);
if (info.auth)
{
info.client = fromClient;
if (!mClients.Any(it => it.client.Equals(fromClient)))
{
mClients.Add(info);
}
outputSocket = new OutputSocketMessage(inputObject.execFun, inputObject.actId, true, "", new { info.nickName, info.login, img = info.photo });
//Организовать отправку остальным пользователям о подключении клиента
using (var db = new RaidaContext())
{
Members iam = db.Members.Include(m => m.MemberInGroup)
.First(it => it.login.Equals(info.login));
SendMessageOfChangeUser(db, iam);
}
Console.WriteLine($"{JsonConvert.SerializeObject(outputSocket)}");
SendMessage(fromClient, outputSocket);
return;
}
else
{
Console.WriteLine("Invalid login or password");
outputSocket = new OutputSocketMessage(inputObject.execFun,
Guid.Empty,
false,
"Invalid login or password",
new { });
SendMessage(fromClient, outputSocket);
return;
}
}
else
{
if (mClients.Any(it => it.client == fromClient) || findClass.Equals(typeof(Registration)))
{
IReflectionActions execClass = (IReflectionActions)Activator.CreateInstance(findClass);
AuthSocketInfo currentUser = mClients.FirstOrDefault(it => it.client == fromClient);
OutputSocketMessageWithUsers response = execClass.Execute(inputObject.data, currentUser?.login, inputObject.actId);
Console.WriteLine($"{JsonConvert.SerializeObject(response.msgForOwner)}");
SendMessage(fromClient, response.msgForOwner);
if (response.msgForOwner.success)
{
Action <AuthSocketInfo> action = delegate(AuthSocketInfo s) { SendMessage(s.client, response.msgForOther); };
mClients.Where(it => response.forUserLogin.Contains(it.login)).ToList().ForEach(it =>
{
Console.WriteLine($"SendFor {it}");
action(it);
});
}
}
else
{
Console.WriteLine("You are not authorized. To continue working you need to login.");
outputSocket = new OutputSocketMessage(inputObject.execFun,
Guid.Empty,
false,
"You are not authorized. To continue working you need to login.",
new { });
SendMessage(fromClient, outputSocket);
return;
}
}
}
else
{
Console.WriteLine($"Function: '{inputObject.execFun}' not found");
outputSocket = new OutputSocketMessage(inputObject.execFun,
Guid.Empty,
false,
$"Function: '{inputObject.execFun}' not found",
new { }
);
SendMessage(fromClient, outputSocket);
return;
}
}
public OutputSocketMessageWithUsers Execute(object val, string myLogin, Guid actId)
{
#region Тестовые данные
/*
* {
* "execFun": "sendMsg",
* "data": {
* "dialogId": "788FEFAD0ED24436AD73D968685110E8",
* "textMsg": "test message for one user",
* "guidMsg": "91D8333FA55B40AFB46CA63E214C93C8",
* "curFrg":"1",
* "totalFrg":"2",
* "transactionId": "80f7efc032dd4a1c97f69fca51ad1100",
* "deathDate": "2511450497620"
* }
* }
*/
#endregion
OutputSocketMessage output = new OutputSocketMessage("sendMsg", actId, true, "", new { });
OutputSocketMessage outputOther = new OutputSocketMessage("sendMsg", Guid.Empty, true, "", new { });
OutputSocketMessageWithUsers rez = new OutputSocketMessageWithUsers();
InputMsgInfo info = DeserializeObject.ParseJSON <InputMsgInfo>(val, output, out rez);
if (info == null)
{
return(rez);
}
using (var db = new RaidaContext())
{
Members owner = db.Members.First(it => it.login.Equals(myLogin));
if (db.Groups.Any(it => it.group_id == info.dialogId && it.MemberInGroup.Any(mg => mg.group == it && mg.member == owner))) //Check created group and member in this group
{
if (!db.Shares.Any(it => it.id == info.msgId)) //Check exist message with Id
{
Groups gr = db.Groups.Include(s => s.Shares).First(it => it.group_id == info.dialogId);
Console.WriteLine(SystemClock.GetInstance().CurrentTime.ToString());
Shares msg = new Shares
{
id = info.msgId,
owner = owner,
current_fragment = info.curFrg,
total_fragment = info.totalFrg,
file_data = Encoding.Unicode.GetBytes(info.textMsg),
file_extention = "none",
kb_size = 0,
sending_date = SystemClock.GetInstance().CurrentTime, // DateTimeOffset.Now.ToUnixTimeSeconds(),
death_date =
info.deathDate > 0
? DateConvert.validateTimestamp(SystemClock.GetInstance().CurrentTime + info.deathDate)
: DateTimeOffset.Now.AddYears(2000).ToUnixTimeSeconds(),
to_group = gr
};
gr.Shares.Add(msg);
db.Shares.Add(msg);
Transaction.saveTransaction(db, info.transactionId, Transaction.TABLE_NAME.SHARES,
msg.id.ToString(), owner);
db.SaveChanges();
List <MemberInGroup> membersInGroup = db.MemberInGroup.Include(m => m.member)
.Where(it => it.group == gr && it.member != owner).ToList();
membersInGroup.ForEach(it => rez.forUserLogin.Add(it.member.login));
string groupNameForOwner = gr.group_name_part,
groupNameForOther = gr.group_name_part;
if (gr.one_to_one)
{
groupNameForOwner = membersInGroup.First(it => it.member != owner).member.nick_name;
groupNameForOther = owner.nick_name;
}
OneMessageInfo newMsg = new OneMessageInfo(msg.id, info.textMsg, msg.current_fragment,
msg.total_fragment, msg.sending_date, owner.nick_name, msg.owner.login);
output.data = new OutGetMsgInfo(gr.group_id, groupNameForOwner, gr.one_to_one, gr.privated,
new List <OneMessageInfo>()
{
newMsg
});
outputOther.data = new OutGetMsgInfo(gr.group_id, groupNameForOther, gr.one_to_one, gr.privated,
new List <OneMessageInfo>()
{
newMsg
});
Transaction.removeMessageAboveLimit(gr);
}
else
{
output.success = false;
output.msgError = "Message with this ID is exist";
output.data = new { id = info.msgId };
rez.msgForOwner = output;
return(rez);
}
}
else
{
output.success = false;
output.msgError = "Dialog is not found";
rez.msgForOwner = output;
return(rez);
}
}
rez.msgForOwner = output;
rez.msgForOther = outputOther;
return(rez);
}
private void WebSocket_NewMessageReceived(WebSocketSession session, string value)
{
OutputSocketMessage outputSocket;
InputSocketMessage socketMessage;
//Преобразование входного сообщения
try
{
socketMessage = JsonConvert.DeserializeObject <InputSocketMessage>(value);
}
catch
{
outputSocket = new OutputSocketMessage("DeserializeObject error:",
false,
String.Format("Input message: '{0}' is not valid", value),
new { }
);
SendMessage(session, JsonConvert.SerializeObject(outputSocket));
return;
}
//Авторизация
if (socketMessage.execFun.Equals("authorization", StringComparison.CurrentCultureIgnoreCase))
{
AuthInfoWithSocket inf = (new MainAction()).Auth(socketMessage.data);
if (inf.auth)
{
inf.socket = session;
mClients.Add(inf);
outputSocket = new OutputSocketMessage(socketMessage.execFun, true, "", new { publicId = inf.publicId });
SendMessage(session, JsonConvert.SerializeObject(outputSocket));
return;
}
else
{
outputSocket = new OutputSocketMessage(socketMessage.execFun,
false,
String.Format("Invalid login or AN"),
new { }
);
SendMessage(session, JsonConvert.SerializeObject(outputSocket));
return;
}
}
else if (socketMessage.execFun.Equals("closesocket") && webSocket != null)
{
session.Send("Socket was closed");
webSocket.Stop();
}
else
{
//Проверка - авторизован ли пользователь
if (mClients.Any(it => it.socket == session) || socketMessage.execFun.Equals("registration", StringComparison.CurrentCultureIgnoreCase))
{
MainAction refClass = new MainAction();
var me = refClass.GetType().GetMethod(socketMessage.execFun.ToLower(), System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
if (me != null)
{
AuthInfoWithSocket currentUser = mClients.FirstOrDefault(it => it.socket == session);
OutputSocketMessageWithUsers response = (OutputSocketMessageWithUsers)me.Invoke(refClass, new object[] { socketMessage.data, currentUser?.publicId });
outputSocket = response.msgForOwner;
SendMessage(session, JsonConvert.SerializeObject(outputSocket));
if (outputSocket.success)
{
Action <AuthInfoWithSocket> action = delegate(AuthInfoWithSocket s) { SendMessage(s.socket, JsonConvert.SerializeObject(response.msgForOther)); };
mClients.Where(it => response.usersId.Contains(it.publicId)).ToList().ForEach(action);
}
}
else
{
outputSocket = new OutputSocketMessage(socketMessage.execFun,
false,
String.Format("Function: '{0}' not found", socketMessage.execFun),
new { }
);
SendMessage(session, JsonConvert.SerializeObject(outputSocket));
return;
}
}
else
{
outputSocket = new OutputSocketMessage(socketMessage.execFun,
false,
"You are not authorized. To continue working you need to login.",
new { }
);
SendMessage(session, JsonConvert.SerializeObject(outputSocket));
return;
}
}
}
