diff --git a/daemon/face/face-flags.hpp b/daemon/face/face-flags.hpp
deleted file mode 100644
index 1451a27..0000000
--- a/daemon/face/face-flags.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
-/**
- * Copyright (c) 2014  Regents of the University of California,
- *                     Arizona Board of Regents,
- *                     Colorado State University,
- *                     University Pierre & Marie Curie, Sorbonne University,
- *                     Washington University in St. Louis,
- *                     Beijing Institute of Technology
- *
- * This file is part of NFD (Named Data Networking Forwarding Daemon).
- * See AUTHORS.md for complete list of NFD authors and contributors.
- *
- * NFD is free software: you can redistribute it and/or modify it under the terms
- * of the GNU General Public License as published by the Free Software Foundation,
- * either version 3 of the License, or (at your option) any later version.
- *
- * NFD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
- **/
-
-#ifndef NFD_DAEMON_MGMT_FACE_FLAGS_HPP
-#define NFD_DAEMON_MGMT_FACE_FLAGS_HPP
-
-#include "face/face.hpp"
-#include <ndn-cxx/management/nfd-face-flags.hpp>
-
-namespace nfd {
-
-inline uint64_t
-getFaceFlags(const Face& face)
-{
-  uint64_t flags = 0;
-  if (face.isLocal()) {
-    flags |= ndn::nfd::FACE_IS_LOCAL;
-  }
-  if (face.isOnDemand()) {
-    flags |= ndn::nfd::FACE_IS_ON_DEMAND;
-  }
-  return flags;
-}
-
-} // namespace nfd
-
-#endif // NFD_DAEMON_MGMT_FACE_FLAGS_HPP
diff --git a/daemon/face/face.cpp b/daemon/face/face.cpp
index bbf2a08..f3757ff 100644
--- a/daemon/face/face.cpp
+++ b/daemon/face/face.cpp
@@ -24,7 +24,6 @@
  */
 
 #include "face.hpp"
-#include "face-flags.hpp"
 #include "core/logger.hpp"
 
 namespace nfd {
@@ -125,19 +124,44 @@
   this->onFail.clear();
 }
 
+template<typename FaceTraits>
+void
+Face::copyStatusTo(FaceTraits& traits) const
+{
+  traits.setFaceId(getId())
+    .setRemoteUri(getRemoteUri().toString())
+    .setLocalUri(getLocalUri().toString());
+
+  if (isLocal()) {
+    traits.setFaceScope(ndn::nfd::FACE_SCOPE_LOCAL);
+  }
+  else {
+    traits.setFaceScope(ndn::nfd::FACE_SCOPE_NON_LOCAL);
+  }
+
+  if (isOnDemand()) {
+    traits.setFacePersistency(ndn::nfd::FACE_PERSISTENCY_ON_DEMAND);
+  }
+  else {
+    traits.setFacePersistency(ndn::nfd::FACE_PERSISTENCY_PERSISTENT);
+  }
+}
+
+template void
+Face::copyStatusTo<ndn::nfd::FaceStatus>(ndn::nfd::FaceStatus&) const;
+
+template void
+Face::copyStatusTo<ndn::nfd::FaceEventNotification>(ndn::nfd::FaceEventNotification&) const;
+
 ndn::nfd::FaceStatus
 Face::getFaceStatus() const
 {
   ndn::nfd::FaceStatus status;
-  status.setFaceId(getId())
-    .setRemoteUri(getRemoteUri().toString())
-    .setLocalUri(getLocalUri().toString())
-    .setFlags(getFaceFlags(*this));
+  copyStatusTo(status);
 
   this->getCounters().copyTo(status);
 
   return status;
 }
 
-
 } //namespace nfd
diff --git a/daemon/face/face.hpp b/daemon/face/face.hpp
index 52c0894..8234102 100644
--- a/daemon/face/face.hpp
+++ b/daemon/face/face.hpp
@@ -32,6 +32,7 @@
 #include "face-counters.hpp"
 
 #include <ndn-cxx/management/nfd-face-status.hpp>
+#include <ndn-cxx/management/nfd-face-event-notification.hpp>
 
 namespace nfd {
 
@@ -163,6 +164,12 @@
   const FaceUri&
   getLocalUri() const;
 
+  /** \return FaceTraits data structure filled with the current FaceTraits status
+   */
+  template<typename FaceTraits>
+  void
+  copyStatusTo(FaceTraits& traits) const;
+
   /** \return FaceStatus data structure filled with the current Face status
    */
   virtual ndn::nfd::FaceStatus
@@ -202,7 +209,6 @@
   friend class FaceTable;
 };
 
-
 inline bool
 Face::isLocal() const
 {
