/// <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 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));
}
}
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 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 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 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 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_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>
/// 查询工作量列表的信息
/// 客户端发送的请求信息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>
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>
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 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 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 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));
}
}
