gameServer2/src/server/handlers/inroom.rs
changeset 14392 e335b3120f59
parent 14374 e5db279308d7
equal deleted inserted replaced
14391:42776184fc39 14392:e335b3120f59
    16         server_chat
    16         server_chat
    17     },
    17     },
    18     utils::is_name_illegal
    18     utils::is_name_illegal
    19 };
    19 };
    20 use std::{
    20 use std::{
    21     mem::swap, fs::{File, OpenOptions},
    21     mem::swap
    22     io::{Read, Write, Result, Error, ErrorKind}
       
    23 };
    22 };
    24 use base64::{encode, decode};
    23 use base64::{encode, decode};
    25 use super::common::rnd_reply;
    24 use super::common::rnd_reply;
    26 use log::*;
    25 use log::*;
    27 
    26 
    97         ToggleRestrictJoin => RoomFlags::RESTRICTED_JOIN,
    96         ToggleRestrictJoin => RoomFlags::RESTRICTED_JOIN,
    98         ToggleRestrictTeams => RoomFlags::RESTRICTED_TEAM_ADD,
    97         ToggleRestrictTeams => RoomFlags::RESTRICTED_TEAM_ADD,
    99         ToggleRegisteredOnly => RoomFlags::RESTRICTED_UNREGISTERED_PLAYERS,
    98         ToggleRegisteredOnly => RoomFlags::RESTRICTED_UNREGISTERED_PLAYERS,
   100         _ => RoomFlags::empty()
    99         _ => RoomFlags::empty()
   101     }
   100     }
   102 }
       
   103 
       
   104 fn read_file(filename: &str) -> Result<String> {
       
   105     let mut reader = File::open(filename)?;
       
   106     let mut result = String::new();
       
   107     reader.read_to_string(&mut result)?;
       
   108     Ok(result)
       
   109 }
       
   110 
       
   111 fn write_file(filename: &str, content: &str) -> Result<()> {
       
   112     let mut writer = OpenOptions::new().create(true).write(true).open(filename)?;
       
   113     writer.write_all(content.as_bytes())
       
   114 }
   101 }
   115 
   102 
   116 pub fn handle(server: &mut HWServer, client_id: ClientId, room_id: RoomId, message: HWProtocolMessage) {
   103 pub fn handle(server: &mut HWServer, client_id: ClientId, room_id: RoomId, message: HWProtocolMessage) {
   117     use crate::protocol::messages::HWProtocolMessage::*;
   104     use crate::protocol::messages::HWProtocolMessage::*;
   118     match message {
   105     match message {
   313             server.react(client_id, actions);
   300             server.react(client_id, actions);
   314         }
   301         }
   315         SaveRoom(filename) => {
   302         SaveRoom(filename) => {
   316             if server.clients[client_id].is_admin() {
   303             if server.clients[client_id].is_admin() {
   317                 let actions = match server.rooms[room_id].get_saves() {
   304                 let actions = match server.rooms[room_id].get_saves() {
   318                     Ok(text) => match write_file(&filename, &text) {
   305                     Ok(text) => match server.io.write_file(&filename, &text) {
   319                         Ok(_) => vec![server_chat("Room configs saved successfully.".to_string())
   306                         Ok(_) => vec![server_chat("Room configs saved successfully.".to_string())
   320                             .send_self().action()],
   307                             .send_self().action()],
   321                         Err(e) => {
   308                         Err(e) => {
   322                             warn!("Error while writing the config file \"{}\": {}", filename, e);
   309                             warn!("Error while writing the config file \"{}\": {}", filename, e);
   323                             vec![Warn("Unable to save the room configs.".to_string())]
   310                             vec![Warn("Unable to save the room configs.".to_string())]
   331                 server.react(client_id, actions);
   318                 server.react(client_id, actions);
   332             }
   319             }
   333         }
   320         }
   334         LoadRoom(filename) => {
   321         LoadRoom(filename) => {
   335             if server.clients[client_id].is_admin() {
   322             if server.clients[client_id].is_admin() {
   336                 let actions = match read_file(&filename) {
   323                 let actions = match server.io.read_file(&filename) {
   337                     Ok(text) => match server.rooms[room_id].set_saves(&text) {
   324                     Ok(text) => match server.rooms[room_id].set_saves(&text) {
   338                         Ok(_) => vec![server_chat("Room configs loaded successfully.".to_string())
   325                         Ok(_) => vec![server_chat("Room configs loaded successfully.".to_string())
   339                             .send_self().action()],
   326                             .send_self().action()],
   340                         Err(e) => {
   327                         Err(e) => {
   341                             warn!("Error while deserializing the room configs: {}", e);
   328                             warn!("Error while deserializing the room configs: {}", e);