static void Main(string[] args)
{
if (args.Length == 0)
{
return;
}
if (args[0] == "update")
{
try
{
string callExeName = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(args[1]));
string updateFileDir = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(args[2]));
string appDir = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(args[3]));
var updateInfo = ByteConvertHelper.Bytes2Object(Convert.FromBase64String(args[4])) as UpdateInfo;
App app = new App();
DownFileProcess downUi = new DownFileProcess(callExeName, updateFileDir, appDir, updateInfo)
{
WindowStartupLocation = WindowStartupLocation.CenterScreen
};
app.Run(downUi);
}
catch (Exception ex)
{
LogerManager.Current.AsyncError("开启升级程序异常：" + ex.Message);
MessageBox.Show(ex.Message);
}
}
}
private void InsertUpdate(user_update_insertupdate_rpc msg)
{
User bodys = Mapper.Map <User>(ByteConvertHelper.Bytes2Object <User>(msg.MessageBodyByte));
UserIndex user = null;
bool isAdd = default(Guid).Equals(bodys.Id);
lock (rpcLocker)
{
if (!isAdd)
{
user = _repository.EditUserIndex(bodys);
}
else
{
var userId = ByteConvertHelper.Bytes2Object <Guid>(msg.MessageBodyReturnByte);
var newUser = _repository.Get(userId);
user = _repository.InsertUserIndex(newUser);
}
InsertIndex(user);
}
if (user != null)
{
msg.MessageBodyReturnByte = ByteConvertHelper.Object2Bytes(user.UserId);
}
}
public IActionResult isLogin()
{
var myJson = new Dictionary <string, object>()
{
{ "success", false },
{ "message", null }
};
byte[] userObject = null;
HttpContext.Session.TryGetValue("CurrentUser", out userObject);
if (userObject != null)
{
var user = ByteConvertHelper.Bytes2Object <UserSimpleDto>(userObject);
myJson["success"] = true;
myJson["user"] = new UserSimpleDto
{
UserName = user.UserName,
FirstName = user.FirstName,
LastName = user.LastName,
Status = user.Status
};
}
return(Json(myJson));
}
private void UpdateRowMenus(role_rolemenus_others_normal msg)
{
if (string.IsNullOrWhiteSpace(msg.CurrentDBStr))
{
throw new Exception("IRepositoryFactory.CreateRepositoryByConnStr need role ConnStr!");
}
RoleMenuMsg bodys = ByteConvertHelper.Bytes2Object <RoleMenuMsg>(msg.MessageBodyByte);
List <RoleMenu> roleMenus = new List <RoleMenu>();
bodys?.menuIds.ForEach(x => { roleMenus.Add(new RoleMenu()
{
RoleId = bodys.Id, MenuId = x
}); });
lock (normalLocker)
{
var repository = _repository.CreateRepositoryByConnStr <Role, IRoleRepository>(msg.CurrentDBStr);
repository.Execute(() =>
{
repository.RemoveRowMenus(bodys.Id);
repository.UnitOfWork.SaveChange();
repository.BatchAddRowMenus(roleMenus);
repository.UnitOfWork.SaveChange();
});
}
}
private void UpdateRowMenus(role_update_rolemenus_normal msg)
{
RoleMenuMsg bodys = ByteConvertHelper.Bytes2Object <RoleMenuMsg>(msg.MessageBodyByte);
List <RoleMenu> roleMenus = new List <RoleMenu>();
bodys?.menuIds.ForEach(x => { roleMenus.Add(new RoleMenu()
{
RoleId = bodys.Id, MenuId = x
}); });
lock (normalLocker)
{
_repository.Execute(() =>
{
_repository.RemoveRowMenus(bodys.Id);
_repository.UnitOfWork.SaveChange();
_repository.BatchAddRowMenus(roleMenus);
_repository.UnitOfWork.SaveChange();
});
}
var connList = _repositoryFactory.GetConnectionStrings();
foreach (var connStr in connList)
{
role_rolemenus_others_normal otherobj = new role_rolemenus_others_normal(_queueService.ExchangeName, bodys, connStr);
_queueService.PublishTopic(otherobj);
}
}
private void Delete(department_delete_others_normal msg)
{
List <Guid> bodys = ByteConvertHelper.Bytes2Object <List <Guid> >(msg.MessageBodyByte);
lock (normalLocker)
{
_repository.CreateRepositoryByConnStr <Department, IDepartmentRepository>(msg.CurrentDBStr).Delete(it => bodys.Contains(it.Id));
}
}
static CurrentUser()
{
byte[] result;
_session.TryGetValue("CurrentUser", out result);
if (!result.IsEmpty())
{
_userViewModel = (UserViewModel)ByteConvertHelper.Bytes2Object(result);
}
}
private void OnConsumerReceived(object sender, BasicDeliverEventArgs e)
{
_deliveryTag = e.DeliveryTag;
var message = ByteConvertHelper.Bytes2Object <T>(e.Body);
if (!_needResponse)
{
OnMessageReceievedToOutSide?.Invoke(sender, message);
}
else
{
bool hasRejected = false;
bool isSuccess = false;
try
{
//_processEvent(_queueName, message);
OnMessageReceievedToOutSide?.Invoke(sender, message);
isSuccess = true;
}
catch (Exception ex)
{
_logger.LogError($"RabbitMQConsumerClient OnConsumerReceived eooro:{message.MessageRouter}", ex);
_responseChannel.BasicReject(e.DeliveryTag, false); //不再重新分发
hasRejected = true;
isSuccess = true;
throw ex;
}
if (_needResponse)//是否需要回执
{
if (isSuccess)
{
try
{
IBasicProperties props = e.BasicProperties;
IBasicProperties replyProps = _responseChannel.CreateBasicProperties();
replyProps.CorrelationId = props.CorrelationId;
_responseChannel.BasicPublish(_exchageName, $"{message.MessageRouter}_reply", null, ByteConvertHelper.Object2Bytes(message)); //发送消息到内容检查队列
if (!hasRejected)
{
_channel.BasicAck(e.DeliveryTag, false); //确认处理成功 此处与不再重新分发，只能出现一次
}
}
catch (Exception Ex)
{
_logger.LogError($"RabbitMQConsumerClient OnConsumerReceived _needResponse error:{message.MessageRouter}", Ex);
throw Ex;
}
}
//else
//{
// _channel.BasicReject(e.DeliveryTag, true); //处理失败，重新分发
//}
}
}
}
private void Delete(user_delete_deleteuser_normal msg)
{
List <Guid> bodys = ByteConvertHelper.Bytes2Object <List <Guid> >(msg.MessageBodyByte);
lock (normalLocker)
{
_repository.DeleteUserIndex(it => bodys.Contains(it.UserId));
DeleteIndex(bodys);
}
}
private void Delete(user_delete_deleteuser_normal msg)
{
List <Guid> bodys = ByteConvertHelper.Bytes2Object <List <Guid> >(msg.MessageBodyByte);
lock (normalLocker)
{
bodys.ForEach(item => {
_repository.CreateRepository <User, IUserRepository>(item.ToString()).Delete(item);//这里efcore自带级联删除
});
}
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
filterContext.HttpContext.Session.TryGetValue("CurrentUser", out var result);
if (result == null)
{
filterContext.Result = new RedirectResult("/Login/Index");
return;
}
ViewBag.UserName = ByteConvertHelper.Bytes2Object <User>(result).Name;
base.OnActionExecuting(filterContext);
}
private void Request(RoleDto dto, RoleDto olddto, role_update_insertupdate_rpc replyMsg, int runcnt)
{
role_update_insertupdate_rpc msg = new role_update_insertupdate_rpc(_queueService.ExchangeName, dto);
_queueService.Request <RoleDto>(dto, olddto, msg, replyMsg, (x, z, y) =>
{
x.Id = ByteConvertHelper.Bytes2Object <Guid>(y.MessageBodyReturnByte);
_logger.LogInformation("role.update.insertupdate.rpc: name:{0} method:{1}", x.Id, "InsertOrUpdate");
InsertOrUpdateCache(x, z);
}, runcnt);
}
public IActionResult changePassword([FromBody] dynamic data)
{
byte[] userObject = null;
HttpContext.Session.TryGetValue("CurrentUser", out userObject);
UserSimpleDto user = null;
if (userObject != null)
{
user = ByteConvertHelper.Bytes2Object <UserSimpleDto>(userObject);
}
return(Json(_service.changePassword(user, (string)data["username"], (string)data["newPassword"], (string)data["passwordhash"])));
}
//判斷用戶是否登入
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
byte[] result;
filterContext.HttpContext.Session.TryGetValue("CurrentUser", out result);
if (result == null)
{
filterContext.Result = new RedirectResult("/login");
return;
}
_currentUser = ByteConvertHelper.Bytes2Object <UserSimpleDto>(result);
base.OnActionExecuting(filterContext);
}
public string GetRedisValue()
{
string str = "xzxzxzxxzx";
DistributedCacheManager.Set("XXX", ByteConvertHelper.Object2Bytes(str), options: new Microsoft.Extensions.Caching.Distributed.DistributedCacheEntryOptions
{
AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(1)
});
var val = DistributedCacheManager.GetByte("XXX");
return((string)ByteConvertHelper.Bytes2Object(val));
}
public ActionResult Get_CurrentUser_UserName()
{
byte[] userObject = null;
HttpContext.Session.TryGetValue("CurrentUser", out userObject);
string UserName = "";
if (userObject != null)
{
UserName = ByteConvertHelper.Bytes2Object <UserSimpleDto>(userObject).UserName;
}
return(Json(UserName));
}
private void Delete(menu_delete_others_normal msg)
{
if (string.IsNullOrWhiteSpace(msg.CurrentDBStr))
{
throw new Exception("IRepositoryFactory.CreateRepositoryByConnStr need menu ConnStr!");
}
List <Guid> bodys = ByteConvertHelper.Bytes2Object <List <Guid> >(msg.MessageBodyByte);
lock (normalLocker)
{
_repository.CreateRepositoryByConnStr <Menu, IMenuRepository>(msg.CurrentDBStr).Delete(it => bodys.Contains(it.Id));
}
}
private void UpdateUserRole(user_update_userroles_normal msg)
{
UserRoleMsg bodys = ByteConvertHelper.Bytes2Object <UserRoleMsg>(msg.MessageBodyByte);
if (bodys == null)
{
return;
}
List <UserRole> userRoles = new List <UserRole>();
Dictionary <Guid, string> userRoleStrs = new Dictionary <Guid, string>(bodys.userIds.Count);
bodys.userIds.ForEach(uid => {
StringBuilder roleStrs = new StringBuilder();
bodys?.roleIds.ForEach(rid => { userRoles.Add(new UserRole()
{
UserId = uid, RoleId = rid
}); roleStrs.Append(rid).Append(","); });
roleStrs.Remove(roleStrs.Length - 1, 1);
userRoleStrs.Add(uid, roleStrs.ToString());
});
lock (normalLocker)
{
bodys.userIds.ForEach(id => {
var up = _repository.CreateRepository <User, IUserRepository>(id.ToString());
up.Execute(() =>
{
//get from indexs
var readindex = _indexReadFactory.CreateIndex <UserIndexs, IUserIndexsIndexRead>(id.ToString(), "authcore1");
var userindex = readindex.FirstOrDefault(new List <KeyValuePair <string, string> >(1)
{
new KeyValuePair <string, string>("id", id.ToString())
});
if (userindex != null)
{
userindex.roles = userRoleStrs[id];
//update indexs
var objindex = _indexFactory.CreateIndex <UserIndexs, IUserIndexsIndex>(id.ToString(), "authcore1");
objindex.Insert(userindex);
}
// Achieving atomicity between original catalog database operation and the IntegrationEventLog thanks to a local transaction
up.RemoveUserRoles(id);
up.UnitOfWork.SaveChange();
up.BatchAddUserRoles(userRoles);
up.UnitOfWork.SaveChange();
});
});
}
}
private void InsertUpdate(department_update_others_normal msg)
{
Department bodys = Mapper.Map <Department>(ByteConvertHelper.Bytes2Object <DepartmentDto>(msg.MessageBodyByte));
Department retobj = null;
lock (rpcLocker)
{
retobj = _repository.CreateRepositoryByConnStr <Department, IDepartmentRepository>(msg.CurrentDBStr).InsertOrUpdate(bodys);
}
if (retobj != null)
{
msg.MessageBodyReturnByte = ByteConvertHelper.Object2Bytes(retobj.Id);
}
}
public ServerResponse <UserDto> getUserInfo()
{
byte[] session = HttpContext.Session.Get("CurrentUser");
if (session == null)
{
return(ServerResponse <UserDto> .createByErrorCodeMessage(10, "用户未登录,无法获取当前用户的信息"));
}
UserDto user = (UserDto)ByteConvertHelper.Bytes2Object <UserDto>(session);
if (user != null)
{
return(ServerResponse <UserDto> .createBySuccess(user));
}
return(ServerResponse <UserDto> .createByErrorCodeMessage(10, "用户未登录,无法获取当前用户的信息"));
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
byte[] result;
filterContext.HttpContext.Session.TryGetValue("CurrentUser", out result);
if (result == null)
{
filterContext.Result = new RedirectResult("/Login/Index");
return;
}
else
{
CurrentUserInfo = ByteConvertHelper.Bytes2Object <CurrentUserInfo>(result);
}
base.OnActionExecuting(filterContext);
}
public MessageBase returnMsg; //返回的msg
private void OnReplyConsumerReceived(object sender, BasicDeliverEventArgs e)
{
Monitor.Enter(obj);
var res = ByteConvertHelper.Bytes2Object <MessageBase>(e.Body);
returnMsg = res;
if (res.MessageBodyByte.Length > 0)
{
_logger.LogDebug($"rabbitmq topic message [{res.Id}] has been published. and rpc received");
}
_deliveryTag = e.DeliveryTag;
Monitor.Pulse(obj);
Monitor.Exit(obj);
}
private void Delete(department_delete_deletedepartment_normal msg)
{
List <Guid> bodys = ByteConvertHelper.Bytes2Object <List <Guid> >(msg.MessageBodyByte);
lock (normalLocker)
{
_repository.Delete(it => bodys.Contains(it.Id));
}
var connList = _repositoryFactory.GetConnectionStrings();
foreach (var connStr in connList)
{
department_delete_others_normal otherobj = new department_delete_others_normal(_queueService.ExchangeName, bodys, connStr);
_queueService.PublishTopic(otherobj);
}
}
public ActionResult Create([FromBody] RoleDto role)
{
byte[] userObject = null;
HttpContext.Session.TryGetValue("CurrentUser", out userObject);
UserSimpleDto UserName = null;
if (userObject != null)
{
UserName = ByteConvertHelper.Bytes2Object <UserSimpleDto>(userObject);
//寫入目前登入帳號
role.CreateUser = UserName.UserName;
role.UpdateUser = UserName.UserName;
}
var myJson = _service.Create_Role(role);
return(Json(myJson));
}
private void InsertUpdate(role_update_others_normal msg)
{
if (string.IsNullOrWhiteSpace(msg.CurrentDBStr))
{
throw new Exception("IRepositoryFactory.CreateRepositoryByConnStr need role ConnStr!");
}
Role bodys = Mapper.Map <Role>(ByteConvertHelper.Bytes2Object <RoleDto>(msg.MessageBodyByte));
Role retobj = null;
lock (rpcLocker)
{//更新分库的基础信息role
retobj = _repository.CreateRepositoryByConnStr <Role, IRoleRepository>(msg.CurrentDBStr).InsertOrUpdate(bodys);
}
if (retobj != null)
{
msg.MessageBodyReturnByte = ByteConvertHelper.Object2Bytes(retobj.Id);
}
}
private void InsertUpdate(menu_update_others_normal msg)
{
if (string.IsNullOrWhiteSpace(msg.CurrentDBStr))
{
throw new Exception("IRepositoryFactory.CreateRepositoryByConnStr need menu ConnStr!");
}
Menu bodys = Mapper.Map <Menu>(ByteConvertHelper.Bytes2Object <MenuDto>(msg.MessageBodyByte));
Menu retobj = null;
lock (rpcLocker)
{
retobj = _repository.CreateRepositoryByConnStr <Menu, IMenuRepository>(msg.CurrentDBStr).InsertOrUpdate(bodys);
}
if (retobj != null)
{
msg.MessageBodyReturnByte = ByteConvertHelper.Object2Bytes(retobj.Id);
}
}
public ResponseModel Get(string key)
{
byte[] result;
_session.TryGetValue(key, out result);
if (result == null)
{
return new ResponseModel {
code = 0, result = "获取失败"
}
}
;
else
{
return new ResponseModel {
code = 200, result = "获取成功", data = ByteConvertHelper.Bytes2Object <UsersModel>(result)
}
};
}
}
public void OnAuthorization(AuthorizationFilterContext filterContext)
{
if (!filterContext.HttpContext.Session.IsAvailable)
{
return;
}
byte[] value;
if (!filterContext.HttpContext.Session.TryGetValue("CurrentUser", out value))
{
return;
}
var user = ByteConvertHelper.Bytes2Object <User>(value);
if (user == null)
{
return;
}
}
private void InsertUpdate(role_update_insertupdate_rpc msg)
{
var dto = ByteConvertHelper.Bytes2Object <RoleDto>(msg.MessageBodyByte);
Role bodys = Mapper.Map <Role>(dto);
Role retobj = null;
lock (rpcLocker)
{
retobj = _repository.InsertOrUpdate(bodys);
}
if (retobj != null)
{
msg.MessageBodyReturnByte = ByteConvertHelper.Object2Bytes(retobj.Id);
}
var connList = _repositoryFactory.GetConnectionStrings();
foreach (var connStr in connList)
{
role_update_others_normal otherobj = new role_update_others_normal(_queueService.ExchangeName, dto, connStr);
_queueService.PublishTopic(otherobj);
}
}
private void InsertUpdate(user_update_insertupdate_rpc msg)
{
User bodys = Mapper.Map <User>(ByteConvertHelper.Bytes2Object <UserDto>(msg.MessageBodyByte));
User user = null;
bool isAdd = default(Guid).Equals(bodys.Id);
lock (rpcLocker)
{
if (!isAdd)
{
user = _repository.CreateRepository <User, IUserRepository>(bodys.Id.ToString()).Update(bodys);
}
else
{
bodys.Id = Guid.NewGuid();
user = _repository.CreateRepository <User, IUserRepository>(bodys.Id.ToString()).Insert(bodys);
}
}
if (user != null)
{
msg.MessageBodyReturnByte = ByteConvertHelper.Object2Bytes(user.Id);
}
}
