//private Employee m_clientEmployee; // 当前客户端登录的员工的信息
//public Employee ClientEmployee
//{
// get { return this.m_clientEmployee; }
// set { this.m_clientEmployee = value; }
//}
#endregion
/// <summary>
/// 构造函数
/// </summary>
/// <param name="clientSocket">会话使用的Socket连接</param>
public AsyncSocketState(Socket clientSocket)
{
this.m_clientSocket = clientSocket;
this.m_clientIp = (IPEndPoint)clientSocket.RemoteEndPoint; // 保存服务器的信息
this.m_socketMessage = new AsyncSocketMessage();
//this.RecvDataBuffer = new byte[this.ClientSocket.ReceiveBufferSize];
this.InitBuffer();
}
private AsyncSocketMessage m_socketMessage; // 接收到的报文信息
#endregion Fields
#region Constructors
/// <summary>
/// 构造函数
/// </summary>
/// <param name="clientSocket">会话使用的Socket连接</param>
public AsyncSocketState(Socket clientSocket)
{
this.m_clientSocket = clientSocket;
this.m_clientIp = (IPEndPoint)clientSocket.RemoteEndPoint; // 保存服务器的信息
this.m_socketMessage = new AsyncSocketMessage();
//this.RecvDataBuffer = new byte[this.ClientSocket.ReceiveBufferSize];
this.InitBuffer();
}
/// <summary>
/// 查询会签单编号为contractId的工作量集合
/// 客户端发送的信息QUERY_WORKLOAD_REQUEST + [String workloadId]
/// 服务器返回的数据 QUERY_WORKLOAD_SUCCESS / QUERY_WORKLOAD_FAILED
/// </summary>
/// <param name="state"></param>
private void RaiseQueryWorkloadRequest(AsyncSocketState state)
{
Console.WriteLine("接收到来自{0}的待删除工作量信息{1}", state.ClientIp, state.SocketMessage.Message);
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "的待删除工作量信息" + state.SocketMessage.Message, LogMessageType.Information));
ServerResponse response = new ServerResponse();
// json数据解包
String contractId = JsonConvert.DeserializeObject<String>(state.SocketMessage.Message);
// 首先判断当前员工是否存在提交的会签字单子
List<ContractWorkload> workloads = DALContractWorkload.QureyContractWorkLoad(contractId);
if (workloads != null)
{
Console.WriteLine("工作量{0}查询成功", contractId);
this.Log.Write(new LogMessage(state.ClientIp + "工作量" + contractId + "查询成功", LogMessageType.Success));
//DELETE_DEPARTMENT_RESPONSE = "DELETE_DEPARTMENT_SUCCESS"; // 用户登录成功信号
response = ServerResponse.QUERY_WORKLOAD_SUCCESS;
}
else
{
Console.WriteLine("工作量{0}查询失败", contractId);
this.Log.Write(new LogMessage(state.ClientIp + "工作量" + contractId + "查询失败", LogMessageType.Error));
//DELETE_DEPARTMENT_RESPONSE = "DELETE_DEPARTMENT_FAILED"; // 用户登录失败信号
response = ServerResponse.QUERY_WORKLOAD_FAILED;
}
if (response.Equals(ServerResponse.QUERY_WORKLOAD_SUCCESS))
{
// 插入员工的响应信息只包含头信息
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response, workloads);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
else
{
// 插入员工的响应信息只包含头信息
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
}
private void RaiseQuerySignDetailRequest(AsyncSocketState state)
{
Console.WriteLine("接收到来自" + state.ClientIp + "的进行查询签字的请求" + state.SocketMessage.Message);
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "的查询签字信息的请求" + state.SocketMessage.Message, LogMessageType.Information));
ServerResponse response = new ServerResponse();
int employeeId = JsonConvert.DeserializeObject<int>(state.SocketMessage.Message);
List<SignatureDetail> details = DALSignatureDetail.QuerySignatureDetail(employeeId);
this.Log.Write(new LogMessage(state.ClientIp + "的进行签字确认的请求", LogMessageType.Information));
if (details != null)
{
Console.WriteLine("来自{0}的签字确认成功");
this.Log.Write(new LogMessage("来自" + state.ClientIp + "的签字确认成功", LogMessageType.Success));
//QUERY_EMPLOYEE_RESPONSE = "QUERY_EMPLOYEE_SUCCESS"; // 用户登录成功信号
response = ServerResponse.QUERY_SIGN_DETAIL_SUCCESS;
}
else
{
Console.WriteLine("查询已完成签字的会签单信息查询失败");
this.Log.Write(new LogMessage(state.ClientIp + "查询已完成签字的会签单信息查询失败", LogMessageType.Error));
//QUERY_EMPLOYEE_RESPONSE = "QUERY_EMPLOYEE_FAILED"; // 用户登录失败信号
response = ServerResponse.QUERY_SIGN_DETAIL_FAILED;
}
// 查询会签单成功则同时发送[报头 + 部门信息]
if (response.Equals(ServerResponse.QUERY_SIGN_DETAIL_SUCCESS))
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response, details);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package)); // 将
}
else // 查询失败则只发报头
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
}
/// <summary>
/// 处理客户端的查询部门请求
/// </summary>
/// <param name="state"></param>
private void RaiseQuerySDepartmentContractCategoryRequest(AsyncSocketState state)
{
Console.WriteLine("接收到来自{0}的待查询权限部门编号{1}", state.ClientIp, state.SocketMessage.Message); // 输出真正的信息
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "待查询权限部门编号" + state.SocketMessage.Message, LogMessageType.Information));
List<ContractCategory> categorys = null;
ServerResponse response = new ServerResponse();
// json数据解包
int departmentId = JsonConvert.DeserializeObject<int>(state.SocketMessage.Message);
// 向数据库中查询部门的信息
categorys = DALContractIdCategory.QuerySDepartmentContractCategory(departmentId);
if (categorys != null)
{
Console.WriteLine("查询部门会签单申请权限成功");
this.Log.Write(new LogMessage(state.ClientIp + "查询部门会签单申请权限成功", LogMessageType.Success));
//QUERY_DEPARTMENT_RESPONSE = "QUERY_DEPARTMENT_SUCCESS"; // 用户登录成功信号
response = ServerResponse.QUERY_SDEP_CON_CATEGORY_SUCCESS;
}
else
{
Console.WriteLine("查询部门会签单申请权限失败");
this.Log.Write(new LogMessage(state.ClientIp + "查询部门会签单申请权限失败", LogMessageType.Error));
//QUERY_DEPARTMENT_RESPONSE = "QUERY_DEPARTMENT_FAILED"; // 用户登录失败信号
response = ServerResponse.QUERY_SDEP_CON_CATEGORY_FAILED;
}
// 查询部门成功则同时发送[报头 + 部门信息]
if (response.Equals(ServerResponse.QUERY_SDEP_CON_CATEGORY_SUCCESS))
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response, categorys);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package)); // 将
}
else // 查询失败则只发报头
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
}
/// <summary>
/// 处理客户端的查询员工请求
/// </summary>
/// <param name="state"></param>
private void RaiseQueryHDJContractTemplateReuqest(AsyncSocketState state)
{
Console.WriteLine("接收到来自" + state.ClientIp + "的查询会签单模版信息" + state.SocketMessage.Message);
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "查询会签单模版信息" + state.SocketMessage.Message, LogMessageType.Information));
ServerResponse response = new ServerResponse();
List<ContractTemplate> conTemps = DALContractTemplate.QueryContractTemplate();
this.Log.Write(new LogMessage(state.ClientIp + "查询到的了所有的会签单", LogMessageType.Information));
if (conTemps != null)
{
Console.WriteLine("会签单模版信息查询成功");
this.Log.Write(new LogMessage(state.ClientIp + "会签单模版信息信息查询成功", LogMessageType.Success));
//QUERY_EMPLOYEE_RESPONSE = "QUERY_EMPLOYEE_SUCCESS"; // 用户登录成功信号
response = ServerResponse.QUERY_CONTRACT_TEMPLATE_SUCCESS;
}
else
{
Console.WriteLine("会签单模版信息查询失败");
this.Log.Write(new LogMessage(state.ClientIp + "会签单模版信息查询失败", LogMessageType.Error));
//QUERY_EMPLOYEE_RESPONSE = "QUERY_EMPLOYEE_FAILED"; // 用户登录失败信号
response = ServerResponse.QUERY_CONTRACT_TEMPLATE_FAILED;
}
// 查询会签单成功则同时发送[报头 + 部门信息]
if (response.Equals(ServerResponse.QUERY_CONTRACT_TEMPLATE_SUCCESS))
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response, conTemps);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package)); // 将
}
else // 查询失败则只发报头
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
}
/// <summary>
/// 查询工作量列表的信息
/// 客户端发送的请求信息QUERY_CONTRACT_WORKLOAD_REQUEST + contractId[string]
/// 服务器返回的信息
/// 成功 QUERY_CONTRACT_WORKLOAD_SUCCESS + List<ContractWorkload>
/// 失败 QUERY_CONTRACT_WORKLOAD_FAILED
/// </summary>
/// <param name="state"></param>
private void RaiseQueryContractWorkloadRequest(AsyncSocketState state)
{
Console.WriteLine("接收到来自{0}的查询会签单的工作量信息{1}", state.ClientIp, state.SocketMessage.Message); // 输出真正的信息
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "的查询会签单的工作量信息" + state.SocketMessage.Message, LogMessageType.Information));
ServerResponse response = new ServerResponse();
// json数据解包
string contractId = JsonConvert.DeserializeObject<string>(state.SocketMessage.Message);
// 首先检测
List<ContractWorkload> workloads = DALContractWorkload.QureyContractWorkLoad(contractId);
if (workloads != null)
{
Console.WriteLine("查询会签单的工作量信息成功");
this.Log.Write(new LogMessage(state.ClientIp + "查询会签单的工作量信息成功", LogMessageType.Success));
response = ServerResponse.QUERY_CONTRACT_WORKLOAD_SUCCESS;
}
else
{
Console.WriteLine("查询会签单的工作量信息失败");
this.Log.Write(new LogMessage(state.ClientIp + "查询会签单的工作量信息失败", LogMessageType.Error));
response = ServerResponse.QUERY_CONTRACT_WORKLOAD_FAILED;
}
// 查询部门成功则同时发送[报头 + 信息]
if (response.Equals(ServerResponse.QUERY_CONTRACT_WORKLOAD_SUCCESS))
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response, workloads);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
else // 查询失败则只发报头
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
}
/// <summary>
/// 提交会签单的时候修改某个工作量的信息工作
/// 客户端发送的信息MODIFY_WORKLOAD_REQUEST + [ContractWorkload workload]
/// 服务器返回的数据 MODIFY_WORKLOAD_SUCCESS / MODIFY_WORKLOAD_FAILED
/// </summary>
/// <param name="state"></param>
private void RaiseModifyWorkloadRequest(AsyncSocketState state)
{
Console.WriteLine("接收到来自{0}的待修改工作量信息{1}", state.ClientIp, state.SocketMessage.Message);
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "的待修改工作量信息" + state.SocketMessage.Message, LogMessageType.Information));
ServerResponse response = new ServerResponse();
// json数据解包
ContractWorkload workload = JsonConvert.DeserializeObject<ContractWorkload>(state.SocketMessage.Message);
// 首先判断当前员工是否存在提交的会签字单子
//if (DALHDJContract.GetEmployeeSubmitedHDJContractCount(employeeId) > 0)
//{
// response = ServerResponse.DELETE_EMPLOYEE_EXIST_CONTRACT;
//}
//else if (DALContractTemplate.GetEmployeeContractTemplateCount(employeeId) > 0)
//{ // 当前员工与某个会签单模版相关联，删除可能导致模版信息不完整， 无法删除
// response = ServerResponse.DELETE_EMPLOYEE_EXIST_CONTEMP;
//}
//else
//{
bool result = DALContractWorkload.ModifyWorkload(workload);
if (result == true)
{
Console.WriteLine("工作量{0}插入成功", workload.Item.Id);
this.Log.Write(new LogMessage("工作量" + workload.Item.Id + "插入成功", LogMessageType.Success));
response = ServerResponse.MODIFY_WORKLOAD_SUCCESS; // 用户登录成功信号
}
else
{
Console.WriteLine("工作量{0}插入失败", workload.Item.Id);
this.Log.Write(new LogMessage("工作量" + workload.Item.Id + "插入失败", LogMessageType.Error));
//INSERT_EMPLOYEE_RESPONSE = "INSERT_EMPLOYEE_FAILED"; // 用户登录失败信号
response = ServerResponse.MODIFY_WORKLOAD_FAILED;
}
// 删除员工的响应信息只包含头信息
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
/// <summary>
/// 插入员工请求的事件的具体信息
/// </summary>
/// <param name="state"></param>
private void RaiseInsertEmployeeRequest(AsyncSocketState state)
{
Console.WriteLine("接收到的来自{0}的待插入员工信息{1}", state.ClientIp, state.SocketMessage.Message);
this.Log.Write(new LogMessage("接收到的来自" + state.ClientIp + "的待插入员工信息" + state.SocketMessage.Message, LogMessageType.Information));
ServerResponse response = new ServerResponse();
// json数据解包
Employee employee = JsonConvert.DeserializeObject<Employee>(state.SocketMessage.Message);
// 首先判断员工信息是否存在，主要检查用户是否存在用户表中
// 由于用户表的主键ID是自动生成的，
// 因此我们检查唯一的成员信息，比如username
if (DALEmployee.IsEmployeeExist(employee) == true) // 如果
{
response = ServerResponse.INSERT_EMPLOYEE_EXIST;
}
else
{
bool result = DALEmployee.InsertEmployee(employee);
if (result == true)
{
Console.WriteLine("员工{0}插入成功", employee.Name);
this.Log.Write(new LogMessage("员工" + employee.Name + "插入成功", LogMessageType.Success));
response = ServerResponse.INSERT_EMPLOYEE_SUCCESS; // 用户登录成功信号
}
else
{
Console.WriteLine("员工{0}插入失败", employee.Name);
this.Log.Write(new LogMessage("员工" + employee.Name + "插入失败", LogMessageType.Error));
//INSERT_EMPLOYEE_RESPONSE = "INSERT_EMPLOYEE_FAILED"; // 用户登录失败信号
response = ServerResponse.INSERT_EMPLOYEE_FAILED;
}
}
if (response.Equals(ServerResponse.INSERT_EMPLOYEE_SUCCESS))
{
// 插入员工的响应信息只包含头信息
employee = DALEmployee.GetEmployee(employee.User.Username);
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response, employee.Id);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
else
{
// 插入员工的响应信息只包含头信息
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
}
/// <summary>
/// 处理客户端的插入会签单模版的请求
/// </summary>
/// <param name="state"></param>
private void RaiseInsertContractTemplateRequest(AsyncSocketState state)
{
Console.WriteLine("接收到来自" + state.ClientIp + "的待插入会签单模版" + state.SocketMessage.Message);
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "待插入会签单模版" + state.SocketMessage.Message, LogMessageType.Information));
ServerResponse response = new ServerResponse();
// json数据解包
ContractTemplate conTemp = JsonConvert.DeserializeObject<ContractTemplate>(state.SocketMessage.Message);
bool result = DALContractTemplate.InsertContractTemplate(conTemp);
if (result == true)
{
Console.WriteLine("会签单模版{0}插入成功", conTemp.Name);
this.Log.Write(new LogMessage("会签单模版" + conTemp.Name + "插入成功", LogMessageType.Success));
// 用户登录成功信号
response = ServerResponse.INSERT_CONTRACT_TEMPLATE_SUCCESS;
}
else
{
Console.WriteLine("会签单模版{0}插入失败", conTemp.Name);
this.Log.Write(new LogMessage("会签单模版" + conTemp.Name + "插入失败", LogMessageType.Error));
response = ServerResponse.INSERT_CONTRACT_TEMPLATE_FAILED; // 用户登录失败信号
}
// 插入会签单模版的响应数据只包含头
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
/// <summary>
/// 获取会签单的信息
/// </summary>
/// <param name="state"></param>
private void RaiseGetHDJContractRequest(AsyncSocketState state)
{
Console.WriteLine("接收到来自" + state.ClientIp + "的待获取的会签单编号" + state.SocketMessage.Message);
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "待获取的会签单编号" + state.SocketMessage.Message, LogMessageType.Information));
//string MODIFY_EMPLOYEE_RESPONSE;
ServerResponse response = new ServerResponse();
// json数据解包
String contractId = JsonConvert.DeserializeObject<String>(state.SocketMessage.Message);
HDJContract contract = DALHDJContract.GetHDJContract(contractId);
if (contract != null)
{
Console.WriteLine(state.ClientIp + "获取会签单{0}成功", contractId);
this.Log.Write(new LogMessage(state.ClientIp + "获取会签单" + contractId + "成功", LogMessageType.Success));
//MODIFY_EMPLOYEE_RESPONSE = "MODIFY_EMPLOYEE_SUCCESS"; // 用户登录成功信号
response = ServerResponse.GET_HDJCONTRACT_SUCCESS;
}
else
{
Console.WriteLine(state.ClientIp + "获取会签单{0}失败", contractId.ToString());
this.Log.Write(new LogMessage(state.ClientIp + "获取会签单" + contractId + "失败", LogMessageType.Error));
// MODIFY_EMPLOYEE_RESPONSE = "MODIFY_EMPLOYEE_FAILED"; // 用户登录失败信号
response = ServerResponse.GET_HDJCONTRACT_FAILED;
}
// 查询会签单成功则同时发送[报头 + 部门信息]
if (response.Equals(ServerResponse.GET_HDJCONTRACT_SUCCESS))
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response, contract);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package)); // 将
}
else // 查询失败则只发报头
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
}
/// <summary>
/// 查询会签单数目--用于提交签字时自动生成最后几位
/// 客户端发送的请求信息GET_CATEGORY_YEAR_CONTRACT_COUNT_REQUEST + search[填充CategoryShortCall + Year两个字段]
/// 服务器返回的信息
/// 成功 GET_CATEGORY_YEAR_CONTRACT_COUNT_SUCCESS + count
/// 失败 GET_CATEGORY_YEAR_CONTRACT_COUNT_FAILED
/// </summary>
/// <param name="state"></param>
private void RaiseGetCategoryYearContractCountRequest(AsyncSocketState state)
{
Console.WriteLine("接收到来自{0}的获取当年该类别会签单已经申请的数目信息{1}", state.ClientIp, state.SocketMessage.Message); // 输出真正的信息
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "的获取当年该类别会签单已经申请的数目信息" + state.SocketMessage.Message, LogMessageType.Information));
ServerResponse response = new ServerResponse();
// json数据解包
Search search = JsonConvert.DeserializeObject<Search>(state.SocketMessage.Message);
// 首先检测
int count = DALHDJContract.GetCategoryYearHDJContractCount(search);
if (count >= 0)
{
Console.WriteLine("获取当年该类别会签单已经申请的数目成功");
this.Log.Write(new LogMessage(state.ClientIp + "获取当年该类别会签单已经申请的数目成功", LogMessageType.Success));
response = ServerResponse.GET_CATEGORY_YEAR_CONTRACT_COUNT_SUCCESS;
}
else
{
Console.WriteLine("获取当年该类别会签单已经申请的数目失败");
this.Log.Write(new LogMessage(state.ClientIp + "获取当年该类别会签单已经申请的数目失败", LogMessageType.Error));
response = ServerResponse.GET_CATEGORY_YEAR_CONTRACT_COUNT_FAILED;
}
// 查询部门成功则同时发送[报头 + 信息]
if (response.Equals(ServerResponse.GET_CATEGORY_YEAR_CONTRACT_COUNT_SUCCESS))
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response, count);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
else // 查询失败则只发报头
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
}
/// <summary>
/// 提交会签单的时候删除某个工作量的信息工作
/// 客户端发送的信息DELETE_WORKLOAD_REQUEST + [String workloadId]
/// 服务器返回的数据 DELETE_WORKLOAD_SUCCESS / DELETE_WORKLOAD_FAILED
/// </summary>
/// <param name="state"></param>
private void RaiseDeleteWorkloadRequest(AsyncSocketState state)
{
Console.WriteLine("接收到来自{0}的待删除工作量信息{1}", state.ClientIp, state.SocketMessage.Message);
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "的待删除工作量信息" + state.SocketMessage.Message, LogMessageType.Information));
ServerResponse response = new ServerResponse();
// json数据解包
String workloadId = JsonConvert.DeserializeObject<String>(state.SocketMessage.Message);
// 首先判断当前员工是否存在提交的会签字单子
bool result = DALContractWorkload.DeleteWorkload(workloadId);
if (result == true)
{
Console.WriteLine("工作量{0}删除成功", workloadId);
this.Log.Write(new LogMessage(state.ClientIp + "工作量" + workloadId + "删除成功", LogMessageType.Success));
//DELETE_DEPARTMENT_RESPONSE = "DELETE_DEPARTMENT_SUCCESS"; // 用户登录成功信号
response = ServerResponse.DELETE_WORKLOAD_SUCCESS;
}
else
{
Console.WriteLine("工作量{0}删除失败", workloadId);
this.Log.Write(new LogMessage(state.ClientIp + "工作量" + workloadId + "删除失败", LogMessageType.Error));
//DELETE_DEPARTMENT_RESPONSE = "DELETE_DEPARTMENT_FAILED"; // 用户登录失败信号
response = ServerResponse.DELETE_WORKLOAD_FAILED;
}
// 删除员工的响应信息只包含头信息
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
/// <summary>
/// 用户删除部门请求的事件的具体信息
/// </summary>
/// <param name="state"></param>
private void RaiseDeleteHDJContractRequest(AsyncSocketState state)
{
Console.WriteLine("接收到来自" + state.ClientIp + "的待删除会签单模版编号" + state.SocketMessage.Message);
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "待插入会签单模版编号" + state.SocketMessage.Message, LogMessageType.Information));
//string DELETE_DEPARTMENT_RESPONSE;
ServerResponse response = new ServerResponse();
// json数据解包
int conTempId = JsonConvert.DeserializeObject<int>(state.SocketMessage.Message);
bool result = DALContractTemplate.DeleteContactTemplate(conTempId);//
if (result == true)
{
Console.WriteLine("会签单模版{0}删除成功", conTempId);
this.Log.Write(new LogMessage(state.ClientIp + "会签单模版" + conTempId.ToString() + "删除成功", LogMessageType.Success));
//DELETE_DEPARTMENT_RESPONSE = "DELETE_DEPARTMENT_SUCCESS"; // 用户登录成功信号
response = ServerResponse.DELETE_CONTRACT_TEMPLATE_SUCCESS;
}
else
{
Console.WriteLine("会签单模版{0}删除失败", conTempId);
this.Log.Write(new LogMessage(state.ClientIp + "会签单模版" + conTempId + "删除失败", LogMessageType.Error));
//DELETE_DEPARTMENT_RESPONSE = "DELETE_DEPARTMENT_FAILED"; // 用户登录失败信号
response = ServerResponse.DELETE_CONTRACT_TEMPLATE_FAILED;
}
// 删除会签单模版的响应数据只包含头
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
/// <summary>
/// 用户删除部门请求的事件的具体信息
/// </summary>
/// <param name="state"></param>
private void RaiseDeleteEmployeeRequest(AsyncSocketState state)
{
Console.WriteLine("接收到来自{0}的待删除员工信息{1}", state.ClientIp, state.SocketMessage.Message);
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "待删除员工信息" + state.SocketMessage.Message, LogMessageType.Information));
ServerResponse response = new ServerResponse();
// json数据解包
int employeeId = JsonConvert.DeserializeObject<int>(state.SocketMessage.Message);
// 首先判断当前员工是否存在提交的会签字单子
if (DALHDJContract.GetEmployeeSubmitedHDJContractCount(employeeId) > 0)
{
response = ServerResponse.DELETE_EMPLOYEE_EXIST_CONTRACT;
}
else if (DALContractTemplate.GetEmployeeContractTemplateCount(employeeId) > 0)
{ // 当前员工与某个会签单模版相关联，删除可能导致模版信息不完整， 无法删除
response = ServerResponse.DELETE_EMPLOYEE_EXIST_CONTEMP;
}
else
{
bool result = DALEmployee.DeleteEmployee(employeeId);
if (result == true)
{
Console.WriteLine("员工{0}删除成功", employeeId);
this.Log.Write(new LogMessage(state.ClientIp + "员工" + employeeId + "删除成功", LogMessageType.Success));
//DELETE_DEPARTMENT_RESPONSE = "DELETE_DEPARTMENT_SUCCESS"; // 用户登录成功信号
response = ServerResponse.DELETE_EMPLOYEE_SUCCESS;
}
else
{
Console.WriteLine("部门{0}删除失败", employeeId);
this.Log.Write(new LogMessage(state.ClientIp + "部门" + employeeId + "删除失败", LogMessageType.Error));
//DELETE_DEPARTMENT_RESPONSE = "DELETE_DEPARTMENT_FAILED"; // 用户登录失败信号
response = ServerResponse.DELETE_EMPLOYEE_FAILED;
}
}
// 删除员工的响应信息只包含头信息
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
/// <summary>
/// 用户修改部门请求的事件的具体信息
/// </summary>
/// <param name="state"></param>
private void RaiseModifySDepartmentRequest(AsyncSocketState state)
{
Console.WriteLine("接收到来自{0}的待修改部门信息{1}", state.ClientIp, state.SocketMessage.Message); // 输出真正的信息
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "的待修改的部门信息" + state.SocketMessage.Message, LogMessageType.Information));
ServerResponse response = new ServerResponse();
// json数据解包
SDepartment department = JsonConvert.DeserializeObject<SDepartment>(state.SocketMessage.Message);
// 首先检测
bool result = DALSDepartment.ModifySDepartment(department);
if (result == true)
{
Console.WriteLine("部门{0}, {1}修改成功", department.Id, department.Name);
this.Log.Write(new LogMessage("部门" + department.Id + ", " + department.Name + "修改成功", LogMessageType.Success));
//MODIFY_DEPARTMENT_RESPONSE = "MODIFY_DEPARTMENT_SUCCESS"; // 用户登录成功信号
response = ServerResponse.MODIFY_SDEPARTMENT_SUCCESS;
}
else
{
Console.WriteLine("部门{0}, {1}修改失败", department.Id, department.Name);
this.Log.Write(new LogMessage("部门" + department.Id + ", " + department.Name + "修改失败", LogMessageType.Error));
//MODIFY_DEPARTMENT_RESPONSE = "MODIFY_DEPARTMENT_FAILED"; // 用户登录失败信号
response = ServerResponse.MODIFY_SDEPARTMENT_FAILED;
}
// 修改部门的响应信息只包含响应头
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
/// <summary>
/// 处理客户端的插入会签单的请求
/// </summary>
/// <param name="state"></param>
private void RaiseInsertHDJContractRequest(AsyncSocketState state)
{
Console.WriteLine("接收到来自" + state.ClientIp + "的待插入会签单信息" + state.SocketMessage.Message);
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "待插入会签单信息" + state.SocketMessage.Message, LogMessageType.Information));
ServerResponse response = new ServerResponse();
// json数据解包
HDJContract contract = JsonConvert.DeserializeObject<HDJContract>(state.SocketMessage.Message);
if (DALHDJContract.IsHDJContractExist(contract.Id) == true)
{
response = ServerResponse.INSERT_HDJCONTRACT_EXIST;
}
else
{
bool result = DALHDJContract.InsertHDJContract(contract);
if (result == true)
{
Console.WriteLine("会签单{0}插入成功", contract.Id);
this.Log.Write(new LogMessage("会签单" + contract.Id + "插入成功", LogMessageType.Success));
// 用户登录成功信号
response = ServerResponse.INSERT_HDJCONTRACT_SUCCESS;
}
else
{
Console.WriteLine("会签单模版{0}插入失败", contract.Id);
this.Log.Write(new LogMessage("会签单模版" + contract.Id + "插入失败", LogMessageType.Error));
response = ServerResponse.INSERT_HDJCONTRACT_FAILED; // 用户登录失败信号
}
}
// 插入会签单模版的响应数据只包含头
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
/// <summary>
///
/// </summary>
/// <param name="state"></param>
private void RaiseQueryAgreeUndownloadHDJContract(AsyncSocketState state)
{
Console.WriteLine("接收到来自" + state.ClientIp + "的查询未被下载的已通过的会签单模版信息" + state.SocketMessage.Message);
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "的查询未被下载的已通过的会签单模版信息" + state.SocketMessage.Message, LogMessageType.Information));
ServerResponse response = new ServerResponse();
int employeeID = JsonConvert.DeserializeObject<int>(state.SocketMessage.Message);
List<SHDJContract> contracts = DALSignatureStatus.QueryAgreeUndownloadContract(employeeID);
this.Log.Write(new LogMessage(state.ClientIp + "查询未被下载的已通过的会签单模版信息", LogMessageType.Information));
if (contracts != null)
{
Console.WriteLine("查询未被下载的已通过的会签单模版信息成功");
this.Log.Write(new LogMessage(state.ClientIp + "查询未被下载的已通过的会签单模版信息", LogMessageType.Success));
//QUERY_EMPLOYEE_RESPONSE = "QUERY_EMPLOYEE_SUCCESS"; // 用户登录成功信号
response = ServerResponse.QUERY_AGREE_UNDOWN_SUCCESS;
}
else
{
Console.WriteLine("查询未被下载的已通过的会签单模版信息失败");
this.Log.Write(new LogMessage(state.ClientIp + "查询未被下载的已通过的会签单模版信息失败", LogMessageType.Error));
//QUERY_EMPLOYEE_RESPONSE = "QUERY_EMPLOYEE_FAILED"; // 用户登录失败信号
response = ServerResponse.QUERY_AGREE_UNDOWN_FAILED;
}
// 查询会签单成功则同时发送[报头 + 部门信息]
if (response.Equals(ServerResponse.QUERY_AGREE_UNDOWN_SUCCESS))
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response, contracts);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package)); // 将
}
else // 查询失败则只发报头
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
}
/// 带权限的插入操作请使用RaiseInsertDepartmentRequest
/// 因为在部门插入的时候，权限信息可以作为迷人信息进行插入
private void RaiseInsertSDepartmentReuqest(AsyncSocketState state)
{
Console.WriteLine("接收到来自{0}的待插入部门信息{1}", state.ClientIp, state.SocketMessage.Message); // 输出真正的信息
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "的待插入的部门信息" + state.SocketMessage.Message, LogMessageType.Information));
ServerResponse response = new ServerResponse();
// json数据解包
SDepartment department = JsonConvert.DeserializeObject<SDepartment>(state.SocketMessage.Message);
bool result = DALSDepartment.InsertSDepartment(department);
if (result == true)
{
Console.WriteLine("部门{0}插入成功", department);
this.Log.Write(new LogMessage("部门" + department.Name + "插入成功", LogMessageType.Success));
//INSERT_DEPARTMENT_RESPONSE = "INSERT_DEPARTMENT_SUCCESS"; // 用户登录成功信号
response = ServerResponse.INSERT_DEPARTMENT_SUCCESS;
}
else
{
Console.WriteLine("部门{0}插入失败", department.Name);
this.Log.Write(new LogMessage("部门" + department.Name + "插入失败", LogMessageType.Error));
//INSERT_DEPARTMENT_RESPONSE = "INSERT_DEPARTMENT_FAILED"; // 用户登录失败信号
response = ServerResponse.INSERT_DEPARTMENT_FAILED;
}
// 插入部门的相应，只是一个响应头
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package)); // 将
}
/// <summary>
/// 处理客户端的查询员工请求
/// </summary>
/// <param name="state"></param>
private void RaiseQueryEmployeeRequest(AsyncSocketState state)
{
Console.WriteLine("客户端{0}待查询的部门的ID = {1}", state.ClientIp, state.SocketMessage.Message);
this.Log.Write(new LogMessage(state.ClientIp + "待查询的员工的编号 = " + state.SocketMessage.Message, LogMessageType.Information));
//String QUERY_EMPLOYEE_RESPONSE;
ServerResponse response = new ServerResponse();
int departmentId = JsonConvert.DeserializeObject<int>(state.SocketMessage.Message);
Console.WriteLine(departmentId);
List<Employee> employees = DALEmployee.QueryEmployee(departmentId);
this.Log.Write(new LogMessage(state.ClientIp + "查询到的部门编号为" + state.SocketMessage.Message + "的所有员工", LogMessageType.Information));
if (employees != null)
{
Console.WriteLine("部门{0}的员工信息查询成功", state.SocketMessage.Message);
this.Log.Write(new LogMessage(state.ClientIp + "部门" + state.SocketMessage.Message + "的员工信息查询成功", LogMessageType.Success));
//QUERY_EMPLOYEE_RESPONSE = "QUERY_EMPLOYEE_SUCCESS"; // 用户登录成功信号
response = ServerResponse.QUERY_EMPLOYEE_SUCCESS;
}
else
{
Console.WriteLine("部门{0}的员工信息查询失败", state.SocketMessage.Message);
this.Log.Write(new LogMessage(state.ClientIp + "部门" + state.SocketMessage.Message + "的员工信息查询失败", LogMessageType.Error));
//QUERY_EMPLOYEE_RESPONSE = "QUERY_EMPLOYEE_FAILED"; // 用户登录失败信号
response = ServerResponse.QUERY_EMPLOYEE_FAILED;
}
// 查询部门成功则同时发送[报头 + 部门信息]
if (response.Equals(ServerResponse.QUERY_EMPLOYEE_SUCCESS))
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response, employees);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package)); // 将
}
else // 查询失败则只发报头
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
}
private void RaiseInsertSignDetailRequest(AsyncSocketState state)
{
Console.WriteLine("接收到来自" + state.ClientIp + "的进行签字确认的请求" + state.SocketMessage.Message);
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "的进行签字确认的请求" + state.SocketMessage.Message, LogMessageType.Information));
ServerResponse response = new ServerResponse();
SignatureDetail detail = JsonConvert.DeserializeObject<SignatureDetail>(state.SocketMessage.Message);
bool result = DALSignatureDetail.InsertSignatureDetail(detail);
this.Log.Write(new LogMessage(state.ClientIp + "的进行签字确认的请求", LogMessageType.Information));
if (result == true)
{
Console.WriteLine("来自{0}的签字确认成功");
this.Log.Write(new LogMessage("来自" + state.ClientIp + "的签字确认成功", LogMessageType.Success));
//QUERY_EMPLOYEE_RESPONSE = "QUERY_EMPLOYEE_SUCCESS"; // 用户登录成功信号
response = ServerResponse.INSERT_SIGN_DETAIL_SUCCESS;
}
else
{
Console.WriteLine("查询已完成签字的会签单信息查询失败");
this.Log.Write(new LogMessage(state.ClientIp + "查询已完成签字的会签单信息查询失败", LogMessageType.Error));
//QUERY_EMPLOYEE_RESPONSE = "QUERY_EMPLOYEE_FAILED"; // 用户登录失败信号
response = ServerResponse.INSERT_SIGN_DETAIL_FAILED;
}
// 查询会签单成功则同时发送[报头 + 部门信息]
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
//////////////////////////////////
this.m_mswordServer.AddContractWhenCanCreated(detail.ConId);
/////////////////////////////////
}
/// <summary>
/// 查询某个会签单项目可以申请的工作量列表的信息
/// 客户端发送的请求信息QUERY_PROJECT_ITEM_REQUEST + projectId[int]
/// 服务器返回的信息
/// 成功 QUERY_PROJECT_ITEM_SUCCESS + List<ContractItem>
/// 失败 QUERY_PROJECT_ITEM_FAILED
/// </summary>
/// <param name="state"></param>
private void RaiseQueryProjectItemRequest(AsyncSocketState state)
{
Console.WriteLine("接收到来自{0}的查询工作量列表的信息{1}", state.ClientIp, state.SocketMessage.Message); // 输出真正的信息
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "的查询工作量列表的信息" + state.SocketMessage.Message, LogMessageType.Information));
ServerResponse response = new ServerResponse();
// json数据解包
int projectId = JsonConvert.DeserializeObject<int>(state.SocketMessage.Message);
// 首先检测
List<ContractItem> items = DALContractItem.QueryProjectItem(projectId);
if (items != null)
{
Console.WriteLine("查询工作量列表成功");
this.Log.Write(new LogMessage(state.ClientIp + "查询工作量列表成功", LogMessageType.Success));
response = ServerResponse.QUERY_PROJECT_ITEM_SUCCESS;
}
else
{
Console.WriteLine("查询工作量列表失败");
this.Log.Write(new LogMessage(state.ClientIp + "查询工作量列表失败", LogMessageType.Error));
response = ServerResponse.QUERY_PROJECT_ITEM_FAILED;
}
// 查询部门成功则同时发送[报头 + 信息]
if (response.Equals(ServerResponse.QUERY_PROJECT_ITEM_SUCCESS))
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response, items);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
else // 查询失败则只发报头
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
}
/// <summary>
/// 提交会签单的时候新增某个工作量的信息工作
/// 客户端发送的信息INSERT_WORKLOAD_REQUEST + [ContractWorkload workload]
/// 服务器返回的数据 INSERT_WORKLOAD_SUCCESS / INSERT_WORKLOAD_FAILED
/// </summary>
/// <param name="state"></param>
private void RaiseInsertWorkloadRequest(AsyncSocketState state)
{
Console.WriteLine("接收到的来自{0}的待插入工作量信息{1}", state.ClientIp, state.SocketMessage.Message);
this.Log.Write(new LogMessage("接收到的来自" + state.ClientIp + "的待工作量信息" + state.SocketMessage.Message, LogMessageType.Information));
ServerResponse response = new ServerResponse();
// json数据解包
ContractWorkload workload = JsonConvert.DeserializeObject<ContractWorkload>(state.SocketMessage.Message);
// 首先判断员工信息是否存在，主要检查用户是否存在用户表中
// 由于用户表的主键ID是自动生成的，
// 因此我们检查唯一的成员信息，比如username
//if (DALEmployee.IsEmployeeExist(employee) == true) // 如果
//{
// response = ServerResponse.INSERT_EMPLOYEE_EXIST;
//}
//else
//{
bool result = DALContractWorkload.InsertWorkload(workload);
if (result == true)
{
Console.WriteLine("工作量{0}插入成功", workload.Item.Id);
this.Log.Write(new LogMessage("工作量" + workload.Item.Id + "插入成功", LogMessageType.Success));
response = ServerResponse.INSERT_WORKLOAD_SUCCESS; // 用户登录成功信号
}
else
{
Console.WriteLine("工作量{0}插入失败", workload.Item.Id);
this.Log.Write(new LogMessage("工作量" + workload.Item.Id + "插入失败", LogMessageType.Error));
//INSERT_EMPLOYEE_RESPONSE = "INSERT_EMPLOYEE_FAILED"; // 用户登录失败信号
response = ServerResponse.INSERT_WORKLOAD_FAILED;
}
//if (response.Equals(ServerResponse.INSERT_WORKLOAD_SUCCESS))
//{
// // 插入员工的响应信息只包含头信息
// employee = DALEmployee.GetEmployee(employee.User.Username);
// AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
// this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
//}
//else
{
// 插入员工的响应信息只包含头信息
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
}
/// <summary>
/// 处理客户端的查询部门请求
/// </summary>
/// <param name="state"></param>
private void RaiseQuerySDepartmentRequest(AsyncSocketState state)
{
List<SDepartment> departments = new List<SDepartment>();
ServerResponse response = new ServerResponse();
// 向数据库中查询部门的信息
departments = DALSDepartment.QuerySDepartment();
if (departments != null)
{
Console.WriteLine("部门信息查询成功");
this.Log.Write(new LogMessage(state.ClientIp + "部门信息查询成功", LogMessageType.Success));
//QUERY_DEPARTMENT_RESPONSE = "QUERY_DEPARTMENT_SUCCESS"; // 用户登录成功信号
response = ServerResponse.QUERY_SDEPARTMENT_SUCCESS;
}
else
{
Console.WriteLine("部门信息查询失败");
this.Log.Write(new LogMessage(state.ClientIp + "部门信息查询失败", LogMessageType.Error));
//QUERY_DEPARTMENT_RESPONSE = "QUERY_DEPARTMENT_FAILED"; // 用户登录失败信号
response = ServerResponse.QUERY_SDEPARTMENT_FAILED;
}
// 查询部门成功则同时发送[报头 + 部门信息]
if (response.Equals(ServerResponse.QUERY_SDEPARTMENT_SUCCESS))
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response, departments);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package)); // 将
}
else // 查询失败则只发报头
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
}
/// <summary>
/// 用户登录请求的事件的具体信息
/// </summary>
/// <param name="state"></param>
private void RaiseLoginRequest(AsyncSocketState state)
{
Console.WriteLine("接收到来自{0}的登录信息{1}", state.ClientIp, state.SocketMessage.Message); // 输出真正的信息
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "的登录信息" + state.SocketMessage.Message, LogMessageType.Information));
//string LOGIN_RESPONSE;
ServerResponse response = new ServerResponse();
// json数据解包
User user = JsonConvert.DeserializeObject<User>(state.SocketMessage.Message);
Employee employee = new Employee();
employee = DALEmployee.LoginEmployee(user); // 如果用户名和密码验证成功
if(employee.Id != -1)
{
Console.WriteLine(user + "用户名密码均正确，可以登录");
this.Log.Write(new LogMessage(user + "用户名密码均正确，可以登录", LogMessageType.Success));
response = ServerResponse.LOGIN_SUCCESS; // 用户登录成功信号
}
else
{
Console.WriteLine(user + "用户名密码验证失败，无法正常登录");
this.Log.Write(new LogMessage(user + "用户名密码验证失败，无法正常登录", LogMessageType.Error));
response = ServerResponse.LOGIN_FAILED; // 用户登录成功信号
}
// 将响应信号发送至客户端
if (response.Equals(ServerResponse.LOGIN_SUCCESS))
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response, employee);
//String json = JsonConvert.SerializeObject(employee);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package)); // 将
//Console.WriteLine("发送给")
}
else
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
//String json = JsonConvert.SerializeObject(employee);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
}
/// <summary>
/// 签字人查询所有待签字的会签单信息
/// </summary>
/// <param name="state"></param>
private void RaiseQueryUnsignContractRequest(AsyncSocketState state)
{
Console.WriteLine("接收到来自" + state.ClientIp + "的查询待签字的会签单信息" + state.SocketMessage.Message);
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "查询待签字的会签单信息" + state.SocketMessage.Message, LogMessageType.Information));
ServerResponse response = new ServerResponse();
int employeeId;
//lock (state.SocketMessage.Message)
//{
employeeId = JsonConvert.DeserializeObject<int>(state.SocketMessage.Message);
//}
List<SHDJContract> contracts = DALSignatureStatus.QueryUnsignContract(employeeId);
this.Log.Write(new LogMessage(state.ClientIp + "查询到的了所有查询待签字的的会签单", LogMessageType.Information));
if (contracts != null)
{
Console.WriteLine("查询待签字的签单信息查询成功");
this.Log.Write(new LogMessage(state.ClientIp + "查询待签字的会签单信息查询成功", LogMessageType.Success));
//QUERY_EMPLOYEE_RESPONSE = "QUERY_EMPLOYEE_SUCCESS"; // 用户登录成功信号
response = ServerResponse.QUERY_UNSIGN_CONTRACT_SUCCESS;
}
else
{
Console.WriteLine("查询待签字的会签单信息查询失败");
this.Log.Write(new LogMessage(state.ClientIp + "查询待签字的会签单信息查询失败", LogMessageType.Error));
//QUERY_EMPLOYEE_RESPONSE = "QUERY_EMPLOYEE_FAILED"; // 用户登录失败信号
response = ServerResponse.QUERY_UNSIGN_CONTRACT_FAILED;
}
// 查询会签单成功则同时发送[报头 + 部门信息]
if (response.Equals(ServerResponse.QUERY_UNSIGN_CONTRACT_SUCCESS))
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response, contracts);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package)); // 将
}
else // 查询失败则只发报头
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
}
/// <summary>
/// 修改员工的密码
/// </summary>
/// <param name="state"></param>
private void RaiseModifyEmployeePasswordRequest(AsyncSocketState state)
{
Console.WriteLine("客户端{0}待修改的密码的信息{1}", state.ClientIp, state.SocketMessage.Message);
this.Log.Write(new LogMessage(state.ClientIp + "待修改的密码的信息 = " + state.SocketMessage.Message, LogMessageType.Information));
ServerResponse response = new ServerResponse();
User user = JsonConvert.DeserializeObject<User>(state.SocketMessage.Message);
Console.WriteLine(user);
bool result = DALEmployee.ModifyEmployeePassword(user);
this.Log.Write(new LogMessage(state.ClientIp + "待修改的密码的信息" + state.SocketMessage.Message, LogMessageType.Information));
if (result == true)
{
Console.WriteLine("修改{0}的员工密码查询成功", state.SocketMessage.Message);
this.Log.Write(new LogMessage(state.ClientIp + "修改" + state.SocketMessage.Message + "的员工密码成功", LogMessageType.Success));
response = ServerResponse.MODIFY_EMP_PWD_SUCCESS;
}
else
{
Console.WriteLine("部门{0}的员工密码查询成功", state.SocketMessage.Message);
this.Log.Write(new LogMessage(state.ClientIp + "修改" + state.SocketMessage.Message + "的员工密码失败", LogMessageType.Error));
response = ServerResponse.MODIFY_EMP_PWD_FAILED;
}
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package)); // 将
}
/// <summary>
/// 查询正在审核，审核通过以及被拒绝的所有会签单的信息
/// </summary>
/// <param name="state"></param>
private void RaiseSearchSignedHDJContractRequest(AsyncSocketState state)
{
Console.WriteLine("接收到来自" + state.ClientIp + "的查询被拒绝的会签单模版信息" + state.SocketMessage.Message);
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "查询被拒绝的会签单模版信息" + state.SocketMessage.Message, LogMessageType.Information));
ServerResponse response = new ServerResponse();
Search search = JsonConvert.DeserializeObject<Search>(state.SocketMessage.Message);
List<SHDJContract> contracts = DALSignatureStatus.SearchSignedHDJContract(search);
this.Log.Write(new LogMessage(state.ClientIp + "查询到的了所有被拒绝的会签单", LogMessageType.Information));
if (contracts != null)
{
Console.WriteLine("被拒绝会签单信息查询成功");
this.Log.Write(new LogMessage(state.ClientIp + "被拒绝会签单信息查询成功", LogMessageType.Success));
//QUERY_EMPLOYEE_RESPONSE = "QUERY_EMPLOYEE_SUCCESS"; // 用户登录成功信号
response = ServerResponse.SEARCH_SIGNED_HDJCONTRACT_SUCCESS;
}
else
{
Console.WriteLine("被拒绝的会签单信息查询失败");
this.Log.Write(new LogMessage(state.ClientIp + "被拒绝的会签单信息查询失败", LogMessageType.Error));
//QUERY_EMPLOYEE_RESPONSE = "QUERY_EMPLOYEE_FAILED"; // 用户登录失败信号
response = ServerResponse.SEARCH_SIGNED_HDJCONTRACT_FAILED;
}
// 查询会签单成功则同时发送[报头 + 部门信息]
if (response.Equals(ServerResponse.SEARCH_SIGNED_HDJCONTRACT_SUCCESS))
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response, contracts);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package)); // 将
}
else // 查询失败则只发报头
{
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
}
/// <summary>
/// 用户修改部门请求的事件的具体信息
/// </summary>
/// <param name="state"></param>
private void RaiseModifyEmployeeRequest(AsyncSocketState state)
{
Console.WriteLine("接收到来自{0}的待修改员工信息{1}", state.ClientIp, state.SocketMessage.Message);
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "待修改员工信息" + state.SocketMessage.Message, LogMessageType.Information));
ServerResponse response = new ServerResponse();
// json数据解包
Employee employee = JsonConvert.DeserializeObject<Employee>(state.SocketMessage.Message);
bool result = DALEmployee.ModifyEmployee(employee);
if (result == true)
{
Console.WriteLine(state.ClientIp + "员工{0}, {1}修改成功", employee.Id, employee.Name);
this.Log.Write(new LogMessage(state.ClientIp + "员工" + employee.Id + ", " + employee.Name + "修改成功", LogMessageType.Success));
//MODIFY_EMPLOYEE_RESPONSE = "MODIFY_EMPLOYEE_SUCCESS"; // 用户登录成功信号
response = ServerResponse.MODIFY_EMPLOYEE_SUCCESS;
}
else
{
Console.WriteLine(state.ClientIp + "员工{0}修改失败", employee.Name);
this.Log.Write(new LogMessage(state.ClientIp + "员工" + employee.Name + "修改失败", LogMessageType.Error));
//MODIFY_EMPLOYEE_RESPONSE = "MODIFY_EMPLOYEE_FAILED"; // 用户登录失败信号
response = ServerResponse.MODIFY_EMPLOYEE_FAILED;
}
// 修改员工额响应信息至包含响应头
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
/// <summary>
/// 用户修改部门请求的事件的具体信息
/// </summary>
/// <param name="state"></param>
private void RaiseModifyHDJContractRequest(AsyncSocketState state)
{
Console.WriteLine("接收到来自" + state.ClientIp + "的待修改会签单信息" + state.SocketMessage.Message);
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "的待修改会签单信息" + state.SocketMessage.Message, LogMessageType.Information));
//string MODIFY_EMPLOYEE_RESPONSE;
ServerResponse response = new ServerResponse();
// json数据解包
HDJContract contract = JsonConvert.DeserializeObject<HDJContract>(state.SocketMessage.Message);
bool result = DALHDJContract.ModifyHDJContract(contract);
if (result == true)
{
Console.WriteLine(state.ClientIp + "会签单信息{0}, {1}修改成功", contract.Id.ToString(), contract.Name);
this.Log.Write(new LogMessage(state.ClientIp + "会签单模版" + contract.Id.ToString() + ", " + contract.Name + "修改成功", LogMessageType.Success));
//MODIFY_EMPLOYEE_RESPONSE = "MODIFY_EMPLOYEE_SUCCESS"; // 用户登录成功信号
response = ServerResponse.MODIFY_HDJCONTRACT_SUCCESS;
}
else
{
Console.WriteLine(state.ClientIp + "会签单模版{0}删除失败", contract.Id.ToString());
this.Log.Write(new LogMessage(state.ClientIp + "会签单模版" + contract.Name + "修改失败", LogMessageType.Error));
// MODIFY_EMPLOYEE_RESPONSE = "MODIFY_EMPLOYEE_FAILED"; // 用户登录失败信号
response = ServerResponse.MODIFY_HDJCONTRACT_FAILED;
}
// 修改会签单模版的响应数据只包含头
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package));
}
/// <summary>
/// 用户删除部门请求的事件的具体信息
/// </summary>
/// <param name="state"></param>
private void RaiseDeleteDepartmentRequest(AsyncSocketState state)
{
Console.WriteLine("接收到来自{0}的待删除部门编号{1}", state.ClientIp, state.SocketMessage.Message); // 输出真正的信息
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "的待删除的部门编号" + state.SocketMessage.Message, LogMessageType.Information));
ServerResponse response = new ServerResponse();
// json数据解包
int departmentId = JsonConvert.DeserializeObject<int>(state.SocketMessage.Message);
// 要删除部门时首先判断该部门的员工个数是否为0
if (DALEmployee.QueryDepartmentEmployeeCount(departmentId) > 0)
{
response = ServerResponse.DELETE_DEPARTMENT_EXIST_EMPLOYEE;
}
else
{
bool result = DALDepartment.DeleteDepartment(departmentId);
if (result == true)
{
Console.WriteLine("部门{0}删除成功", departmentId);
this.Log.Write(new LogMessage("部门" + departmentId + "删除成功", LogMessageType.Success));
response = ServerResponse.DELETE_DEPARTMENT_SUCCESS; // 用户登录成功信号
}
else
{
Console.WriteLine("部门{0}删除失败", departmentId);
this.Log.Write(new LogMessage("部门" + departmentId + "删除失败", LogMessageType.Error));
//DELETE_DEPARTMENT_RESPONSE = "DELETE_DEPARTMENT_FAILED"; // 用户登录失败信号
response = ServerResponse.DELETE_DEPARTMENT_FAILED;
}
}
// 删除部门的响应信息只包含响应头
AsyncSocketMessage socketMessage = new AsyncSocketMessage(response);
this.Send(state.ClientSocket, Encoding.UTF8.GetBytes(socketMessage.Package)); // 将
}
