//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)); // 将 }