// 套接字信息事件
public AsyncSocketEventArgs(AsyncSocketState state)
{
this.m_state = state;
IsHandled = false;
//System.Net.IPEndPoint ip = (System.Net.IPEndPoint)state.ClientSocket.RemoteEndPoint;
//Console.WriteLine("获取到一个来自" + ip.Address + " : " + ip.Port + "的连接...");
}
/// <summary>
/// 处理客户端连接
/// BeginAccept的回调函数
/// 当BeginAccept()方法调用结束后，一旦新的连接发生，将调用回调函数，
/// 而该回调函数必须包括用来结束接入连接操作的EndAccept()方法。
/// 该方法参数列表为 Socket EndAccept(IAsyncResult iar)
/// </summary>
/// <param name="ar"></param>
private void HandleAcceptConnected(IAsyncResult ar)
{
try
{
if (IsRunning)
{
Socket server = (Socket)ar.AsyncState;
Socket client = server.EndAccept(ar); // EndAccept后，就可以进行正常的通信了
// 检查是否达到最大的允许的客户端数目
if (this.m_currClientCount >= this.m_maxClientCount)
{
//C-TODO 触发事件
RaiseOtherException(null);
}
else // 处理客户端的连接
{
// 再来，我们可以利用事件在EndCallback触发事件，我再加入一个委派AsyncEventArgs以及AsyncEventHandler
// 然后在EndCallback触发AsyncEventHandler，这样一来UI程序便能接收到回报事件状态了。
AsyncSocketState state = new AsyncSocketState(client);
lock (this.m_clientList) // 将连接的客户端的信息添加到客户端列表
{
this.m_clientList.Add(state);
this.m_currClientCount++;
RaiseClientConnected(state); // 触发客户端连接事件
//IPEndPoint ip = (IPEndPoint)client.RemoteEndPoint;
//Console.WriteLine("获取到一个来自{0} : {1}的连接, 当前连接的客户端数据{2}", ip.Address, ip.Port, this.m_currClientCount);
//this.Log.Write(new LogMessage("获取到一个来自" + ip.Address + " : " + ip.Port + "的连接, 当前连接的客户端数据" + this.m_currClientCount.ToString(), LogMessageType.Information));
}
////////////////////////////////////////////////////////////
// modify by gatieme 2015-07-13 21:56
// 修复了一处性能BUG,
// why you allocate new buffers time and time again -
// this is the only opperation here that should take any resources (CPU/memory)
// at http://stackoverflow.com/questions/9915101/performance-of-receiveasync-vs-beginreceive
//
// 设置与客户端的通信的缓冲区
//state.RecvDataBuffer = new byte[client.ReceiveBufferSize];
////////////////////////////////////////////////////////////
/// 开始接受来自该客户端的数据
///
/// 接收数据自BeginRecive开始，
/// 调用回调函数函数HandleDataReceived
/// 在回调函数中以EndReceive结束
client.BeginReceive(state.RecvDataBuffer, 0, state.RecvDataBuffer.Length, SocketFlags.None,
new AsyncCallback(HandleDataReceived), state);
}
//接受下一个请求
server.BeginAccept(new AsyncCallback(HandleAcceptConnected), ar.AsyncState);
}
}
catch (Exception e)
{
// C- TODO 异常处理
Console.WriteLine(e.ToString());
this.Log.Write(new LogMessage(e.ToString(), LogMessageType.Exception));
////////////////////////// BIG BUG//
// 异常后继续监听连接接受下一个请求
////////////////////////////////////
Socket server = (Socket)ar.AsyncState;
server.BeginAccept(new AsyncCallback(HandleAcceptConnected), ar.AsyncState);
}
}
private void RaiseUploadSigaturePicture(AsyncSocketState state)
{
Console.WriteLine("接收到来自" + state.ClientIp + "上传签字图片的请求" + state.SocketMessage.Message);
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "上传签字图片的请求" + state.SocketMessage.Message, LogMessageType.Information));
String employeeId = JsonConvert.DeserializeObject<String>(state.SocketMessage.Message);
//ServerResponse response = new ServerResponse();
Console.WriteLine("开始上传签字图片");
//因为终端每次发送文件的最大缓冲区是512字节，所以每次接收也是定义为512字节
byte[] buffer = new byte[512];
int size = 0;
long len = 0;
string fileName = SIGNATURE_PICTURE_PATH + employeeId + ".jpg";//获得用户保存文件的路径
try
{
//创建文件流，然后让文件流来根据路径创建一个文件
FileStream fs = new FileStream(fileName, FileMode.Create);
//从终端不停的接受数据，然后写入文件里面，只到接受到的数据为0为止，则中断连接
while ((size = state.ClientSocket.Receive(buffer, 0, buffer.Length, SocketFlags.None)) > 0)
{
// Console.WriteLine(Encoding.UTF8.GetString(buffer));
fs.Write(buffer, 0, size);
len += size;
}
fs.Flush();
Console.WriteLine("上传签字图片成功");
}
catch(Exception ex)
{
state.Close();
Console.WriteLine(ex.ToString());
}
}
/// <summary>
/// 处理客户端的所有请求
/// </summary>
/// <param name="ar"></param>
public void DealClientRequest(AsyncSocketState state)
{
// 设置数据包
state.SocketMessage.Package = Encoding.UTF8.GetString(state.RecvDataBuffer, 0, state.RecvLength);
Console.WriteLine("接收到的数据{0}, 大小{1}", state.SocketMessage.Package, state.SocketMessage.Package.Length);
this.Log.Write(new LogMessage("接收到的数据 " + state.SocketMessage.Package + ", 大小" + state.SocketMessage.Package.Length.ToString(), LogMessageType.Information));
do
{
if (state.SocketMessage.Split() == AsyncSocketMessageFlag.MESSAGE_UNKOWN) // 将数据包分割
{
break;
}
//state.SocketMessage.Split();
//foreach (string str in state.SocketMessage.Splits)
//{
// Console.WriteLine(str);
//}
switch (state.SocketMessage.Head)
{
/// <summary>
/// ==用户操作==
/// 用户登录 LOGIN_REQUEST
/// 用户退出 QUIT_REQUEST
/// </summary>
case "LOGIN_REQUEST": // 用户登录信息
RaiseLoginRequest(state);
break;
case "QUIT_REQUEST":
RaiseQuitRequest(state); /// 处理用户的退出请求
break;
case "UPLOAD_PICTURE_REQUEST": // 上传签字图片
RaiseUploadSigaturePicture(state);
break;
case "DOWNLOAD_HDJCONTRACT": // 下载会签单
RaiseDownloadHDJContract(state);
break;
/// <summary>
/// ==部门操作==
/// 增加部门 INSERT_DEPARTMENT_REQUEST
/// 删除部门 DELETE_DEPARTMENT_REQUEST
/// 修改部门 MODIFY_DEPARTMENT_REQUEST
/// 查询部门 QUERY_DEPARTMENT_REQUEST
/// </summary>
#region 部门操作
case "INSERT_DEPARTMENT_REQUEST": // 添加部门请求
// 开始接收期望添加进入数据的库的部门的信息
RaiseInsertDepartmentRequest(state);
break;
case "DELETE_DEPARTMENT_REQUEST":
RaiseDeleteDepartmentRequest(state);
break;
case "MODIFY_DEPARTMENT_REQUEST":
RaiseModifyDepartmentRequest(state);
break;
case "QUERY_DEPARTMENT_REQUEST":
// 注意查询部门的时候，客户端只需要发送请求信息头就可以了
/*state.ClientSocket.BeginReceive(state.RecvDataBuffer, 0, state.RecvDataBuffer.Length, SocketFlags.None,
new AsyncCallback(HandleQueryDepartmentRequestDataReceived), state);*/
RaiseQueryDepartmentRequest(state);
break;
// modify by gatieme at 2015-08-26
case "INSERT_SDEPARTMENT_REQUEST": // 添加部门请求
// 开始接收期望添加进入数据的库的部门的信息
RaiseInsertSDepartmentRequest(state);
break;
case "QUERY_SDEPARTMENT_REQUEST":
RaiseQuerySDepartmentRequest(state);
break;
case "MODIFY_SDEPARTMENT_REQUEST":
RaiseModifySDepartmentRequest(state);
break;
#endregion 部门操作
/// <summary>
/// ==员工操作==
/// 增加员工 INSERT_EMPLOYEE_REQUEST
/// 删除员工 DELETE_EMPLOYEE_REQUEST
/// 修改员工 MODIFY_EMPLOYEE_REQUEST
/// 查询员工 QUERY_ERMPLOYEE_REQUEST
/// </summary>
#region 员工操作
case "INSERT_EMPLOYEE_REQUEST":
RaiseInsertEmployeeRequest(state);
break;
case "DELETE_EMPLOYEE_REQUEST":
RaiseDeleteEmployeeRequest(state);
break;
case "MODIFY_EMPLOYEE_REQUEST":
RaiseModifyEmployeeRequest(state);
break;
case "QUERY_EMPLOYEE_REQUEST":
RaiseQueryEmployeeRequest(state);
break;
case "MODIFY_EMP_PWD_REQUEST":
RaiseModifyEmployeePasswordRequest(state);
break;
#endregion
/// <summary>
/// ==会签单模版操作==
/// 增加会签单模版 INSERT_CONTRACT_TEMPLATE_REQUEST
/// 删除会签单模版 DELETE_CONTRACT_TEMPLATE_REQUEST
/// 修改会签单模版 MODIFY_CONTRACT_TEMPLATE_REQUEST
/// 查询会签单模版 QUERY_CONTRACT_TEMPLATE_REQUEST
/// </summary>
#region 会签单模版操作
case "INSERT_CONTRACT_TEMPLATE_REQUEST":
RaiseInsertContractTemplateRequest(state);
break;
case "DELETE_CONTRACT_TEMPLATE_REQUEST":
RaiseDeleteContractTemplateRequest(state);
break;
case "MODIFY_CONTRACT_TEMPLATE_REQUEST":
RaiseModifyContractTemplateRequest(state);
break;
case "QUERY_CONTRACT_TEMPLATE_REQUEST":
RaiseQueryContractTemplateRequest(state);
break;
case "GET_CONTRACT_TEMPLATE_REQUEST":
RaiseGetContractTemplateRequest(state);
break;
#endregion
/// <summary>
/// ==航道局会签单操作==
/// 增加会签单模版 INSERT_HDJCONTRACT_REQUEST
/// 删除会签单模版 DELETE_HDJCONTRACT_REQUEST
/// 修改会签单模版 MODIFY_HDJCONTRACT_REQUEST
/// 查询会签单模版 QUERY_HDJCONTRACT_REQUEST
/// </summary>
#region 航道局会签单操作
case "INSERT_HDJCONTRACT_REQUEST":
RaiseInsertHDJContractRequest(state);
break;
case "DELETE_HDJCONTRACT_REQUEST":
RaiseDeleteHDJContractRequest(state);
break;
case "MODIFY_HDJCONTRACT_REQUEST":
RaiseModifyHDJContractRequest(state);
break;
case "QUERY_HDJCONTRACT_REQUEST":
RaiseQueryHDJContractTemplateReuqest(state);
break;
case "GET_HDJCONTRACT_REQUEST":
RaiseGetHDJContractRequest(state);
break;
#endregion
/// <summary>
/// ==提交人的会签单状态操作==
/// 查询正在审核会签单 QUERY_SIGN_PEND_REQUEST
/// 查询已经通过会签单 QUERY_SIGN_AGREE_REQUEST
/// 查询被拒绝的会签单 QUERY_SIGN_REFUSE_REQUEST
/// </summary>
#region 提交人的会签单状态操作
case "QUERY_SIGN_PEND_REQUEST":
RaiseQuerySignatureStatusPenddingRequest(state);
break;
case "QUERY_SIGN_AGREE_REQUEST":
RaiseQuerySignatureStatusAgreeRequest(state);
break;
case "QUERY_SIGN_REFUSE_REQUEST":
RaiseQuerySignatureStatusRefuseRequest(state);
break;
case "SEARCH_AGREE_HDJCONTRACT_REQUEST":
RaiseSearchAgreeHDJContractRequest(state);
break;
case "QUERY_AGREE_UNDOWN_REQUEST":
RaiseQueryAgreeUndownloadHDJContract(state);
break;
#endregion
/// <summary>
/// ==签字人的会签单操作==
/// 查询本人需要签字的会签单 QUERY_UNSIGN_CONTRACT_REQUEST
/// 查询本人已经签字会签单 QUERY_SIGNED_CONTRACT_REQUEST
/// 进行签字确认 QUERY_SIGN_REFUSE_REQUEST
/// </summary>
case "QUERY_UNSIGN_CONTRACT_REQUEST":
RaiseQueryUnsignContractRequest(state);
break;
case "QUERY_SIGNED_CONTRACT_REQUEST":
RaiseQuerySignedContractRequest(state);
break;
case "QUERY_SIGNED_CONTRACT_TOP_REQUEST" :
RaiseQuerySignedContractTopRequest(state);
break;
case "SEARCH_SIGNED_HDJCONTRACT_REQUEST":
RaiseSearchSignedHDJContractRequest(state);
break;
/// <summary>
/// ==签字人的签字操作==
/// 用户对某个单子进行签字 INSERT_SIGN_DETAIL_REQUEST
/// 用户查询自己的签单明细 QUERY_SIGN_DETAIL_REQUEST
/// 签字人查询自己EMP对于会签单CON的请求 QUERY_SIGN_DETAIL_EMP_CON_REQUEST
/// </summary>
case "INSERT_SIGN_DETAIL_REQUEST": // 用户对某个单子进行签字
RaiseInsertSignDetailRequest(state);
//////// 此处数据库里会进行判断一个签字阶段是否结束
//////// 同时应用程序会判断一个会签单时候可以生成
//// 会签单信息已经完成，直接生成会签单信息
break;
case "QUERY_SIGN_DETAIL_REQUEST": // 用户查询自己的签单明细
RaiseQuerySignDetailRequest(state);
break;
case "QUERY_SIGN_DETAIL_CON_REQUEST": // 签字人查询自己EMP对于会签单CON的请求
RaiseQuerySignDetailContractRequest(state);
break;
/// <summary>
/// ==处理工作量信息==
/// </summary>
case "INSERT_WORKLOAD_REQUEST" :
RaiseInsertWorkloadRequest(state);
break;
case "DELETE_WORKLOAD_REQUEST" :
RaiseDeleteWorkloadRequest(state);
break;
case "MODIFY_WORKLOAD_REQUEST" :
RaiseModifyWorkloadRequest(state);
break;
case "QUERY_WORKLOAD_REQUEST" :
RaiseModifyWorkloadRequest(state);
break;
/// <summary>
/// ==新增统计功能==
/// </summary>
case "QUERY_SDEP_CON_CATEGORY_REQUEST": // 用于在申请会签单时，根据部门获取对应的可申请权限
// 暂时使用此接口而废弃下一个接口 QUERY_SDEPARTMENT_CATEGORY_REQUEST
// 使用此接口需要在获取时候每次都向数据库获取当前部门的权限信息
// 但是接口使用起来比较方便
RaiseQuerySDepartmentContractCategoryRequest(state);
break;
case "QUERY_SDEPARTMENT_CATEGORY_REQUEST": // 用于在申请会签单时获取带部门带可申请权限的全信息部门信息
// 此接口暂时废弃，，
// 使用此方法可以使用户选择时无需每次都向服务器提交REQUEST
// 但是可能需要在Department中增加新的数据成员
//RaiseQuerySDepartmentCategoryRequest(state);
break;
case "QUERY_CATEGORY_PROJECT_REQUEST":
RaiseQueryCategoryProjectRequest(state);
break;
case "QUERY_PROJECT_ITEM_REQUEST":
RaiseQueryProjectItemRequest(state);
break;
case "QUERY_CONTRACT_WORKLOAD_REQUEST":
RaiseQueryContractWorkloadRequest(state);
break;
}
//this.Close(state);
}while(state.SocketMessage.Flag != AsyncSocketMessageFlag.MESSAGE_RIGHT);
}
/// <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));
}
}
private void RaiseQuitRequest(AsyncSocketState state)
{
Console.WriteLine("接收到来自{0}的退出信息{1}", state.ClientIp, state.SocketMessage.Message); // 输出真正的信息
this.Log.Write(new LogMessage("接收到来自" + state.ClientIp + "的退出信息" + state.SocketMessage.Message, LogMessageType.Information));
// 用户请求退出时，无需返回信息，直接销毁用户的信息即可
//Close(state);
//state = null;
}
/// <summary>
/// 触发网络错误事件
/// </summary>
/// <param name="state"></param>
private void RaiseNetError(AsyncSocketState state)
{
if (NetError != null)
{
NetError(this, new AsyncSocketEventArgs(state));
}
}
/// <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 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>
/// 提交会签单的时候修改某个工作量的信息工作
/// 客户端发送的信息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 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 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 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 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 RaiseOtherException(AsyncSocketState state, string descrip)
{
if (OtherException != null)
{
OtherException(this, new AsyncSocketEventArgs(descrip, state));
}
}
/// <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));
}
}
private void RaiseOtherException(AsyncSocketState state)
{
RaiseOtherException(state, "");
}
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 RaisePrepareSend(AsyncSocketState state)
{
if (PrepareSend != null)
{
PrepareSend(this, new AsyncSocketEventArgs(state));
}
}
/// <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));
}
}
/// <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));
}
}
/// <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>
/// 查询工作量列表的信息
/// 客户端发送的请求信息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>
/// 关闭一个与客户端之间的会话
/// </summary>
/// <param name="state">需要关闭的客户端会话对象</param>
public void Close(AsyncSocketState state)
{
//if (state != null && state.ClientSocket.Connected == false)
if(state != null)
{
state.Datagram = null;
state.RecvDataBuffer = null;
this.m_clientList.Remove(state);
this.m_currClientCount--;
IPEndPoint ip = (IPEndPoint)state.ClientIp;
Console.WriteLine("客户端终止，关闭了客户端{0}:{1}, 当前连接的客户端数目{2}", ip.Address, ip.Port, this.m_currClientCount);
this.Log.Write(new LogMessage("客户端终止，关闭了客户端, 当前连接的客户端数目" + this.m_currClientCount, LogMessageType.Error));
//TODO 触发关闭事件
state.Close();
//state = null;
}
}
/// <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));
}
}
/// <summary>
/// 发送数据
/// </summary>
/// <param name="state">接收数据的客户端会话</param>
/// <param name="data">数据报文</param>
public void Send(AsyncSocketState state, byte[] data)
{
RaisePrepareSend(state);
Send(state.ClientSocket, data);
}
/// <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));
}
}
// 套接字 + 信息
public AsyncSocketEventArgs(string message, AsyncSocketState state)
{
this.m_message = message;
this.m_state = state;
IsHandled = false;
}
/// <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));
}
}
// 套接字 + 信息
public AsyncSocketEventArgs(string message, AsyncSocketState state)
{
this.m_message = message;
this.m_state = state;
IsHandled = false;
}
/// <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));
}
}
