private Employee convertEmployeeFormToEmployee(EmployeeForm employeeForm) {

    if (employeeForm.getPosition() == Position.Cook) {
      Cook employee = new Cook();
      List<CookedDishes> cookedDishes = new ArrayList<>();
      List<String> cookedDishesIdList =
          convertDelimitedStringToList(employeeForm.getCookedDishes());

      populateEmployee(employeeForm, employee);
      cookedDishesIdList.forEach(
          id -> cookedDishes.add(cookedDishesServiceDao.findById(Integer.parseInt(id))));
      employee.setCookedDishes(cookedDishes);

      return employee;

    } else if (employeeForm.getPosition() == Position.Waiter) {
      Waiter employee = new Waiter();
      List<Orders> orders = new ArrayList<>();
      List<String> ordersIdList = convertDelimitedStringToList(employeeForm.getOrders());

      ordersIdList.forEach(id -> orders.add(orderServiceDao.findById(Integer.parseInt(id))));
      populateEmployee(employeeForm, employee);
      employee.setOrders(orders);

      return employee;

    } else {
      Employee employee = new Employee();
      populateEmployee(employeeForm, employee);

      return employee;
    }
  }
Beispiel #2
0
 public void yellingForFood() {
   System.out.println("Is anybody here to give me some food?");
   Cook c = new Cook();
   System.out.println("Cook is ready to cook.");
   // Cook starts to cook all dishes he knows one by one.
   c.makeBurger();
   c.makeFish();
   // More food....
 }
  private EmployeeForm convertEmployeeToEmployeeForm(Employee employee) {

    EmployeeForm employeeForm = new EmployeeForm();

    if (employee.getPosition() == Position.Cook) {
      Cook cook = (Cook) employee;
      List<String> cookedDishesIdList = new ArrayList<>();
      List<CookedDishes> cookedDishes = cook.getCookedDishes();

      cookedDishes.forEach(dish -> cookedDishesIdList.add(dish.getId().toString()));
      String cookedDishesString = convertListToDelimitedString(cookedDishesIdList);
      employeeForm.setCookedDishes(cookedDishesString);
      populateEmployeeForm(employeeForm, cook);

      if ("".equals(employeeForm.getCookedDishes())) {
        employeeForm.setCookedDishes("No cooked dishes");
      }

      return employeeForm;

    } else if (employee.getPosition() == Position.Waiter) {
      Waiter waiter = (Waiter) employee;
      List<String> ordersIdList = new ArrayList<>();
      List<Orders> orders = waiter.getOrders();

      orders.forEach(order -> ordersIdList.add(order.getId().toString()));
      String ordersString = convertListToDelimitedString(ordersIdList);

      employeeForm.setOrders(ordersString);
      populateEmployeeForm(employeeForm, waiter);

      if ("".equals(employeeForm.getOrders())) {
        employeeForm.setOrders("No orders");
      }

      return employeeForm;

    } else {
      populateEmployeeForm(employeeForm, employee);

      return employeeForm;
    }
  }
    @Override
    public void run() {
      super.run();
      Log.d("johnchain", "Commander in");

      try {
        socket = new DatagramSocket(Values.LOCAL_PORT); // bind local port
      } catch (SocketException e) {
        e.printStackTrace();
      }
      if (socket == null) {
        Log.e("johnchain", "Commander socket is null, transmition aborted");
        return;
      }

      Log.e("johnchain", "Commander bind port to socket done");

      DatagramPacket recvPacket = null;
      DatagramPacket sendPacket = null;
      SynAck synPack = new SynAck();
      synPack.threadNum = Values.THREAD_NUMBER;
      synPack.port[0] = 9999;
      synPack.port[1] = 9989;
      synPack.fileInfo.blockSize = Values.BODYLEN;

      Cook cook = new Cook();
      cook.msg = commanderToMainHandler;
      Thread cookThread = new Thread(cook);
      Values.cookLive = true;
      cookThread.start();

      //			if(true) return ;

      while (Values.commanderLive) {

        while (Values.commanderLive && Values.fileQueue.isEmpty()) {
          synchronized (Values.fileQueue) {
            try {
              Values.fileQueue.wait(2000);
            } catch (InterruptedException e) {
              Log.d("johnchain", "Commander interrupted while wait for fileQueue");
              continue;
            }
          }
          Log.d("johnchain", "Commander check fileQueue again");
        }

        Values.fileName = (String) Values.fileQueue.poll();
        if (Values.fileName == null) {
          continue;
        }

        File taskFile = new File(Values.path + Values.fileName);
        File confFile = new File(Values.path + ".diag_log.conf");

        Values.fileSize = (int) taskFile.length();
        if (Values.fileSize % Values.BODYLEN == 0)
          Values.blockNum = Values.fileSize / Values.BODYLEN;
        else Values.blockNum = Values.fileSize / Values.BODYLEN + 1;

        if (Values.isNewTask == true) {

          synPack.downloadable = 0;
          Values.downloadedBlock = 0;
          Values.taskArray = new int[Values.blockNum];
        } else {
          Values.isNewTask = true; // 此处设置,仅对第一次启动时为断点传输情况有效

          synPack.downloadable = 1;
          // TODO 计算已下载数据块总数
          for (int i : Values.taskArray) {
            if (i == Values.DONE) Values.downloadedBlock++;
          }
          if (Values.downloadedBlock == Values.blockNum) {
            Log.e("johnchain", "Commander transmition already finished");
            return;
          }
        }

        synPack.fileInfo.fileName = Values.fileName;
        synPack.fileInfo.fileSize = Values.fileSize;
        synPack.fileInfo.blockNum = Values.blockNum;
        synPack.fileInfo.downloadedBlock = Values.downloadedBlock;

        PacketManager mag =
            new PacketManager(Values.HEAD, Values.SYN, 0, Values.SYNACKLEN, null, synPack);
        sendPacket =
            new DatagramPacket(
                mag.getBuf(), mag.getBuf().length, Values.SERV_ADDRESS, Values.SERV_PORT);

        /* 发送连接请求 */
        Log.d(
            "johnchain",
            "Commander Sent SYN detail(bytes: "
                + sendPacket.getLength()
                + ") : "
                + Utils.stringSynAck(synPack));

        try {
          socket.send(sendPacket);
        } catch (IOException e1) {
          Log.e(
              "johnchain", "Commander Network error, Network unreachable and transmition aborted");
          Values.cookLive = false;
          Values.soldierLive = false;
          Values.commanderLive = false;
          return;
        }

        /* 等待请求回应 */
        final byte[] buf = new byte[Values.MAXLEN];
        recvPacket = new DatagramPacket(buf, buf.length);

        int i;
        for (i = 0; i < 3; i++) {
          try {
            socket.setSoTimeout(Values.SOCKET_TIMEOUT);
            socket.receive(recvPacket);
            break;
          } catch (IOException e) {
            Log.e("johnchain", "Commander timed out to receive SYN_ACK, send SYN again");
            continue;
          }
        }
        if (i == 3) {
          Log.e("johnchain", "Commander fail to receive SYN_ACK, please check the network");
          return;
        }
        Log.d("johnchain", "Commander recv SYN_ACK byte length = " + recvPacket.getLength());
        MyMessage myMsg = PacketManager.depack2(recvPacket.getData());
        Log.d("johnchain", "Commander recv SYN_ACK byte " + Utils.stringSynAck(myMsg.synackPack));

        Message m = commanderToMainHandler.obtainMessage();
        m.obj = myMsg;
        m.what = Values.MT_SYN;
        //				commanderToMainHandler.sendMessage(m);

        initNew();

        if (true) {
          try {
            Thread.sleep(1000);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          //                    continue;
        }

        //                monitorSoldier(myMsg);

        /* 记录下传输信息 */
        //                FileOutputStream outputStream;
        //                try {
        //                    Properties p = new Properties();
        //                    outputStream = new FileOutputStream(confFile);
        //                    p.setProperty("fileName", Values.fileName);
        //                    p.setProperty("fileSize", Integer.toString(Values.fileSize));
        //                    p.setProperty("costtime", Long.toString(Values.timeCost));
        //                    p.setProperty("detail", Arrays.toString(Values.taskArray));
        //                    p.store(outputStream, "Init in commander");
        //                    outputStream.flush();
        //                    outputStream.close();
        //                } catch (FileNotFoundException e) {
        //                    Log.e("johnchain", "Commander configure file not exists");
        //                } catch (IOException e) {
        //                    Log.e("johnchain", "Commander configure file operate error");
        //                }
        //				break;
      }

      Log.d("johnchain", "Commander exit while");
      Values.cookLive = false;
      try {
        //                cook.join();
        cookThread.join();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }

      socket.close();
      Log.d("johnchain", "Commander exit");
    }