Package org.simpleframework.xml

Examples of org.simpleframework.xml.Serializer


        final File path = given.getParentFile();

        // First, check if there already is a merged file. In that case, load it.
        if (new File(file + ".merged").exists()) {
            try {
                final Serializer serializer = new Persister(new XMLTransformationMatcher());
                return serializer.read(SessionRecordImpl.class, new File(file + ".merged"));
            } catch (final Exception e) {
                e.printStackTrace();
            }
        }

        // Check how many files we have
        final File[] listFiles = path.listFiles(new FilenameFilter() {

            @Override
            public boolean accept(final File dir, final String name) {
                if (name.endsWith("session.xml")) return false;
                if (name.endsWith(".xml")) return true;
                return false;
            }
        });

        String suffix = "";

        // TODO: Check last .xml if it's corrupt or not.

        // If we have more files, merge them
        if (listFiles.length > 1 && tryMerge) {
            /*
            final String[] files = new String[listFiles.length];

            for (int i = 0; i < files.length; i++) {
                files[i] = SessionMerger.readFileAsString(listFiles[i].getAbsolutePath());
            }

            final String merge = SessionMerger.merge(files);

            suffix = ".merged";

            try {
                final BufferedWriter out = new BufferedWriter(new FileWriter(file + suffix));
                out.write(merge);
                out.close();
            } catch (final IOException e1) {
                e1.printStackTrace();
            }*/
        }

        final File inFile = new File(file + suffix);
        File tmp = null;
        try {
            tmp = File.createTempFile("prefix", "suffix");
        } catch (IOException e1) {
            e1.printStackTrace();
        }

        final List<String> readLines = IO.readLines(inFile);
        final List<String> writeLines = new ArrayList<String>();
        for (String string : readLines) {
            String replaced = string;

            replaced = replaced.replaceAll("de.dfki.km.augmentedtext.browserplugin.services.sessionrecorder.events", "de.dfki.km.text20.browserplugin.services.sessionrecorder.events");
            replaced = replaced.replaceAll("de.dfki.km.augmentedtext.util.recorder.events", "de.dfki.km.text20.browserplugin.services.sessionrecorder.events");

            //System.out.println(replaced);
            writeLines.add(replaced);

        }
        IO.writeLines(tmp, writeLines);

        final SessionRecordImpl rval = null;
        try {
            final Serializer serializer = new Persister(new XMLTransformationMatcher());
            return serializer.read(SessionRecordImpl.class, tmp);
        } catch (final Exception e) {
            e.printStackTrace();
        }

        return rval;
View Full Code Here


    public synchronized void writeTo(final String file, final boolean incremental) {
        if (incremental) {
            try {
                final long time = System.currentTimeMillis();
                final String clusterFile = file.replaceAll("\\.xml", "." + time + ".xml");
                final Serializer serializer = new Persister(new XMLTransformationMatcher());
                serializer.write(this, new File(clusterFile));
                this.allEvents.clear();

                // Touch reference file
                new File(file).createNewFile();
            } catch (final Exception e) {
                e.printStackTrace();
            }

        } else {
            try {
                final Serializer serializer = new Persister(new XMLTransformationMatcher());
                serializer.write(this, new File(file));
            } catch (final Exception e) {
                e.printStackTrace();
            }

        }
View Full Code Here

 
  /**
   * Reloads the database
   */
  public void reinitialise() {
    Serializer serializer = new Persister();
    try {
      String respath = System.getProperty("res.path");
      if(respath==null)
        respath="";
      InputStream source = FileLoader.loadFile(respath+"res/items/items.xml");
      m_instance = serializer.read(ItemDatabase.class, source);
      System.out.println("INFO: Items database loaded.");
    } catch (Exception e) {
      System.err.println("ERROR: Item database could not be loaded.");
    }
  }
View Full Code Here

    String classe = chaines[chaines.length - 2];

    @SuppressWarnings("unchecked")
    Class<? extends BasicBean> c = (Class<? extends BasicBean>) Class
        .forName(classe);
    Serializer serializer = new Persister();

    return serializer.read(c, f);
  }
View Full Code Here

    File f = new File(dir, name);
    // create file only if exist
    f.createNewFile();

    Serializer serializer = new Persister();
    serializer.write(objet, f);
    return f;
  }
View Full Code Here

     */
    {
      Registry registry = new Registry();
      Strategy strategy = new RegistryStrategy(registry);
      RegistryMatcher matcher = new RegistryMatcher(); //TODO need to be removed in the later versions
      Serializer serializer = new Persister(strategy, matcher);

      matcher.bind(Long.class, LongTransform.class);
      registry.bind(Date.class, DateConverter.class);
      registry.bind(User.class, new UserConverter(usersDao, usersMap));
     
      List<Configuration> list = readList(serializer, f, "configs.xml", "configs", Configuration.class, true);
      for (Configuration c : list) {
        if (c.getConf_key() == null || c.getDeleted()) {
          continue;
        }
        Configuration cfg = configurationDao.forceGet(c.getConf_key());
        if (cfg != null && !cfg.getDeleted()) {
          log.warn("Non deleted configuration with same key is found! old value: {}, new value: {}", cfg.getConf_value(), c.getConf_value());
        }
        c.setConfiguration_id(cfg == null ? null : cfg.getConfiguration_id());
        if (c.getUser() != null && c.getUser().getUser_id() == null) {
          c.setUser(null);
        }
        if (CONFIG_CRYPT_KEY.equals(c.getConf_key())) {
          try {
            Class.forName(c.getConf_value());
          } catch (ClassNotFoundException e) {
            c.setConf_value(MD5Implementation.class.getCanonicalName());
          }
        }
        configurationDao.update(c, null);
      }
    }

    log.info("Configs import complete, starting organization import");
    /*
     * ##################### Import Organizations
     */
    Serializer simpleSerializer = new Persister();
    {
      List<Organisation> list = readList(simpleSerializer, f, "organizations.xml", "organisations", Organisation.class);
      for (Organisation o : list) {
        long oldId = o.getOrganisation_id();
        o.setOrganisation_id(null);
        o = organisationDao.update(o, null);
        organisationsMap.put(oldId, o.getOrganisation_id());
      }
    }

    log.info("Organizations import complete, starting user import");
    /*
     * ##################### Import Users
     */
    {
      String jNameTimeZone = configurationDao.getConfValue("default.timezone", String.class, "Europe/Berlin");
      List<User> list = readUserList(f, "users.xml", "users");
      int minLoginLength = getMinLoginLength(configurationDao);
      for (User u : list) {
        if (u.getLogin() == null) {
          continue;
        }
        if (u.getType() == Type.contact && u.getLogin().length() < minLoginLength) {
          u.setLogin(UUID.randomUUID().toString());
        }
        //FIXME: OPENMEETINGS-750
        //Convert old Backups with OmTimeZone to new schema
       
        String tz = u.getTimeZoneId();
        if (tz == null) {
          u.setTimeZoneId(jNameTimeZone);
          u.setForceTimeZoneCheck(true);
        } else {
          u.setForceTimeZoneCheck(false);
        }
       
        u.setStarttime(new Date());
        long userId = u.getUser_id();
        u.setUser_id(null);
        if (u.getSipUser() != null && u.getSipUser().getId() != 0) {
          u.getSipUser().setId(0);
        }
        usersDao.update(u, -1L);
        usersMap.put(userId, u.getUser_id());
      }
    }

    log.info("Users import complete, starting room import");
    /*
     * ##################### Import Rooms
     */
    {
      Registry registry = new Registry();
      Strategy strategy = new RegistryStrategy(registry);
      RegistryMatcher matcher = new RegistryMatcher(); //TODO need to be removed in the later versions
      Serializer serializer = new Persister(strategy, matcher);

      matcher.bind(Long.class, LongTransform.class);
      matcher.bind(Integer.class, IntegerTransform.class);
      registry.bind(User.class, new UserConverter(usersDao, usersMap));
      registry.bind(RoomType.class, new RoomTypeConverter(roomTypeDao));
     
      List<Room> list = readList(serializer, f, "rooms.xml", "rooms", Room.class);
      for (Room r : list) {
        Long roomId = r.getRooms_id();

        // We need to reset ids as openJPA reject to store them otherwise
        r.setRooms_id(null);
        if (r.getModerators() != null) {
          for (Iterator<RoomModerator> i = r.getModerators().iterator(); i.hasNext();) {
            RoomModerator rm = i.next();
            if (rm.getUser().getUser_id() == null) {
              i.remove();
            }
          }
        }
        r = roomDao.update(r, null);
        roomsMap.put(roomId, r.getRooms_id());
      }
    }

    log.info("Room import complete, starting room organizations import");
    /*
     * ##################### Import Room Organisations
     */
    {
      Registry registry = new Registry();
      Strategy strategy = new RegistryStrategy(registry);
      Serializer serializer = new Persister(strategy);
 
      registry.bind(Organisation.class, new OrganisationConverter(orgDao, organisationsMap));
      registry.bind(Room.class, new RoomConverter(roomDao, roomsMap));
     
      List<RoomOrganisation> list = readList(serializer, f, "rooms_organisation.xml", "room_organisations", RoomOrganisation.class);
      for (RoomOrganisation ro : list) {
        if (!ro.getDeleted()) {
          // We need to reset this as openJPA reject to store them otherwise
          ro.setRooms_organisation_id(null);
          roomOrganisationDao.update(ro, null);
        }
      }
    }

    log.info("Room organizations import complete, starting chat messages import");
    /*
     * ##################### Import Chat messages
     */
    {
      Registry registry = new Registry();
      Strategy strategy = new RegistryStrategy(registry);
      Serializer serializer = new Persister(strategy);
 
      registry.bind(User.class, new UserConverter(usersDao, usersMap));
      registry.bind(Room.class, new RoomConverter(roomDao, roomsMap));
     
      List<ChatMessage> list = readList(serializer, f, "chat_messages.xml", "chat_messages", ChatMessage.class, true);
      for (ChatMessage m : list) {
        chatDao.update(m);
      }
    }
   
    log.info("Chat messages import complete, starting appointement import");
    /*
     * ##################### Import Appointements
     */
    {
      Registry registry = new Registry();
      Strategy strategy = new RegistryStrategy(registry);
      Serializer serializer = new Persister(strategy);
 
      registry.bind(AppointmentCategory.class, new AppointmentCategoryConverter(appointmentCategoryDaoImpl));
      registry.bind(User.class, new UserConverter(usersDao, usersMap));
      registry.bind(AppointmentReminderTyps.class, new AppointmentReminderTypeConverter(appointmentReminderTypDaoImpl));
      registry.bind(Room.class, new RoomConverter(roomDao, roomsMap));
      registry.bind(Date.class, DateConverter.class);
     
      List<Appointment> list = readList(serializer, f, "appointements.xml", "appointments", Appointment.class);
      for (Appointment a : list) {
        Long appId = a.getId();

        // We need to reset this as openJPA reject to store them otherwise
        a.setId(null);
        if (a.getOwner() != null && a.getOwner().getUser_id() == null) {
          a.setOwner(null);
        }
        if (a.getRoom() != null && a.getRoom().getRooms_id() == null) {
          a.setRoom(null);
        }
        Long newAppId = appointmentDao.addAppointmentObj(a);
        appointmentsMap.put(appId, newAppId);
      }
    }

    log.info("Appointement import complete, starting meeting members import");
    /*
     * ##################### Import MeetingMembers
     *
     * Reminder Invitations will be NOT send!
     */
    {
      List<MeetingMember> list = readMeetingMemberList(f, "meetingmembers.xml", "meetingmembers");
      for (MeetingMember ma : list) {
        meetingMemberDao.update(ma);
      }
    }

    log.info("Meeting members import complete, starting ldap config import");
    /*
     * ##################### Import LDAP Configs
     */
    {
      List<LdapConfig> list = readList(simpleSerializer, f, "ldapconfigs.xml", "ldapconfigs", LdapConfig.class, true);
      for (LdapConfig c : list) {
        ldapConfigDao.addLdapConfigByObject(c);
      }
    }

    log.info("Ldap config import complete, starting cluster servers import");
    /*
     * ##################### Cluster servers
     */
    {
      List<Server> list = readList(simpleSerializer, f, "servers.xml", "servers", Server.class, true);
      for (Server s : list) {
        serverDao.update(s, null);
      }
    }

    log.info("Cluster servers import complete, starting OAuth2 servers import");
    /*
     * ##################### OAuth2 servers
     */
    {
      List<OAuthServer> list = readList(simpleSerializer, f, "oauth2servers.xml", "oauth2servers", OAuthServer.class, true);
      for (OAuthServer s : list) {
        auth2Dao.update(s, null);
      }
    }

    log.info("OAuth2 servers import complete, starting recordings import");
    /*
     * ##################### Import Recordings
     */
    {
      Registry registry = new Registry();
      Strategy strategy = new RegistryStrategy(registry);
      RegistryMatcher matcher = new RegistryMatcher(); //TODO need to be removed in the later versions
      Serializer serializer = new Persister(strategy, matcher);

      matcher.bind(Long.class, LongTransform.class);
      matcher.bind(Integer.class, IntegerTransform.class);
      registry.bind(Date.class, DateConverter.class);
     
      List<FlvRecording> list = readList(serializer, f, "flvRecordings.xml", "flvrecordings", FlvRecording.class, true);
      for (FlvRecording fr : list) {
        fr.setFlvRecordingId(0);
        if (fr.getRoom_id() != null) {
          fr.setRoom_id(roomsMap.get(fr.getRoom_id()));
        }
        if (fr.getOwnerId() != null) {
          fr.setOwnerId(usersMap.get(fr.getOwnerId()));
        }
        if (fr.getFlvRecordingMetaData() != null) {
          for (FlvRecordingMetaData meta : fr.getFlvRecordingMetaData()) {
            meta.setFlvRecordingMetaDataId(0);
            meta.setFlvRecording(fr);
          }
        }
        flvRecordingDao.update(fr);
      }
    }

    log.info("FLVrecording import complete, starting private message folder import");
    /*
     * ##################### Import Private Message Folders
     */
    {
      List<PrivateMessageFolder> list = readList(simpleSerializer, f, "privateMessageFolder.xml"
        , "privatemessagefolders", PrivateMessageFolder.class, true);
      for (PrivateMessageFolder p : list) {
        Long folderId = p.getPrivateMessageFolderId();
        PrivateMessageFolder storedFolder = privateMessageFolderDao.get(folderId);
        if (storedFolder == null) {
          p.setPrivateMessageFolderId(0);
          Long newFolderId = privateMessageFolderDao.addPrivateMessageFolderObj(p);
          messageFoldersMap.put(folderId, newFolderId);
        }
      }
    }

    log.info("Private message folder import complete, starting user contacts import");
    /*
     * ##################### Import User Contacts
     */
    {
      Registry registry = new Registry();
      Strategy strategy = new RegistryStrategy(registry);
      Serializer serializer = new Persister(strategy);
 
      registry.bind(User.class, new UserConverter(usersDao, usersMap));
     
      List<UserContact> list = readList(serializer, f, "userContacts.xml", "usercontacts", UserContact.class, true);
      for (UserContact uc : list) {
        Long ucId = uc.getUserContactId();
        UserContact storedUC = userContactsDao.get(ucId);

        if (storedUC == null && uc.getContact() != null && uc.getContact().getUser_id() != null) {
          uc.setUserContactId(0);
          if (uc.getOwner() != null && uc.getOwner().getUser_id() == null) {
            uc.setOwner(null);
          }
          Long newId = userContactsDao.addUserContactObj(uc);
          userContactsMap.put(ucId, newId);
        }
      }
    }

    log.info("Usercontact import complete, starting private messages item import");
    /*
     * ##################### Import Private Messages
     */
    {
      Registry registry = new Registry();
      Strategy strategy = new RegistryStrategy(registry);
      Serializer serializer = new Persister(strategy);
 
      registry.bind(User.class, new UserConverter(usersDao, usersMap));
      registry.bind(Room.class, new RoomConverter(roomDao, roomsMap));
      registry.bind(Date.class, DateConverter.class);
     
      List<PrivateMessage> list = readList(serializer, f, "privateMessages.xml", "privatemessages", PrivateMessage.class, true);
      boolean oldBackup = true;
      for (PrivateMessage p : list) {
        if (p.getFolderId() < 0) {
          oldBackup = false;
          break;
        }
       
      }
      for (PrivateMessage p : list) {
        p.setId(0);
        p.setFolderId(getNewId(p.getFolderId(), Maps.MESSAGEFOLDERS));
        p.setUserContactId(getNewId(p.getUserContactId(), Maps.USERCONTACTS));
        if (p.getRoom() != null && p.getRoom().getRooms_id() == null) {
          p.setRoom(null);
        }
        if (p.getTo() != null && p.getTo().getUser_id() == null) {
          p.setTo(null);
        }
        if (p.getFrom() != null && p.getFrom().getUser_id() == null) {
          p.setFrom(null);
        }
        if (p.getOwner() != null && p.getOwner().getUser_id() == null) {
          p.setOwner(null);
        }
        if (oldBackup && p.getOwner() != null && p.getOwner().getUser_id() != null
            && p.getFrom() != null && p.getFrom().getUser_id() != null
            && p.getOwner().getUser_id() == p.getFrom().getUser_id())
        {
          p.setFolderId(SENT_FOLDER_ID);
        }
        privateMessagesDao.update(p, null);
      }
    }

    log.info("Private message import complete, starting file explorer item import");
    /*
     * ##################### Import File-Explorer Items
     */
    {
      Registry registry = new Registry();
      Strategy strategy = new RegistryStrategy(registry);
      RegistryMatcher matcher = new RegistryMatcher(); //TODO need to be removed in the later versions
      Serializer serializer = new Persister(strategy, matcher);

      matcher.bind(Long.class, LongTransform.class);
      matcher.bind(Integer.class, IntegerTransform.class);
      registry.bind(Date.class, DateConverter.class);
     
      List<FileExplorerItem> list = readList(serializer, f, "fileExplorerItems.xml", "fileExplorerItems", FileExplorerItem.class, true);
      for (FileExplorerItem file : list) {
        // We need to reset this as openJPA reject to store them otherwise
        file.setFileExplorerItemId(0);
        Long roomId = file.getRoom_id();
        file.setRoom_id(roomsMap.containsKey(roomId) ? roomsMap.get(roomId) : null);
        if (file.getOwnerId() != null) {
          file.setOwnerId(usersMap.get(file.getOwnerId()));
        }
        fileExplorerItemDao.addFileExplorerItem(file);
      }
    }

    log.info("File explorer item import complete, starting file poll import");
    /*
     * ##################### Import Room Polls
     */
    {
      Registry registry = new Registry();
      Strategy strategy = new RegistryStrategy(registry);
      RegistryMatcher matcher = new RegistryMatcher(); //TODO need to be removed in the later versions
      Serializer serializer = new Persister(strategy, matcher);
 
      matcher.bind(Integer.class, IntegerTransform.class);
      registry.bind(User.class, new UserConverter(usersDao, usersMap));
      registry.bind(Room.class, new RoomConverter(roomDao, roomsMap));
      registry.bind(PollType.class, new PollTypeConverter(pollManager));
View Full Code Here

 
  //FIXME (need to be removed in later versions) HACK to add external attendees previously stored in MeetingMember structure
  private List<MeetingMember> readMeetingMemberList(File baseDir, String filename, String listNodeName) throws Exception {
    Registry registry = new Registry();
    Strategy strategy = new RegistryStrategy(registry);
    Serializer ser = new Persister(strategy);

    registry.bind(User.class, new UserConverter(usersDao, usersMap));
    registry.bind(Appointment.class, new AppointmentConverter(appointmentDao, appointmentsMap));
   
    File xml = new File(baseDir, filename);
    if (!xml.exists()) {
      throw new Exception(filename + " missing");
    }
   
    DocumentBuilder dBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
    Document doc = dBuilder.parse(new InputSource(xml.toURI().toASCIIString()));
   
    StringWriter sw = new StringWriter();
    Transformer xformer = TransformerFactory.newInstance().newTransformer();
        xformer.transform(new DOMSource(doc), new StreamResult(sw));
       
    List<MeetingMember> list = new ArrayList<MeetingMember>();
    InputNode root = NodeBuilder.read(new StringReader(sw.toString()));
    InputNode root1 = NodeBuilder.read(new StringReader(sw.toString())); //HACK to handle external attendee's firstname, lastname, email
    InputNode listNode = root.getNext();
    InputNode listNode1 = root1.getNext(); //HACK to handle external attendee's firstname, lastname, email
    if (listNodeName.equals(listNode.getName())) {
      InputNode item = listNode.getNext();
      InputNode item1 = listNode1.getNext(); //HACK to handle external attendee's firstname, lastname, email
      while (item != null) {
        MeetingMember mm = ser.read(MeetingMember.class, item, false);

        boolean needToSkip1 = true;
        if (mm.getUser() == null) {
          mm.setUser(new User());
        }
View Full Code Here

 
  //FIXME (need to be removed in later versions) HACK to fix 2 deleted nodes in users.xml and inline Adresses and sipData
  private List<User> readUserList(InputSource xml, String listNodeName) throws Exception {
    Registry registry = new Registry();
    Strategy strategy = new RegistryStrategy(registry);
    Serializer ser = new Persister(strategy);

    registry.bind(Organisation.class, new OrganisationConverter(orgDao, organisationsMap));
    registry.bind(State.class, new StateConverter(statemanagement));
    registry.bind(Date.class, DateConverter.class);

    DocumentBuilder dBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
    Document doc = dBuilder.parse(xml);
    NodeList nl = getNode(getNode(doc, "root"), listNodeName).getChildNodes();
    userEmailMap.clear();
    //add existence email from database
    List<User>  users = usersDao.getAllUsers();
    for (User u : users){
      if (u.getAdresses() == null || u.getAdresses().getEmail() == null) {
        continue;
      }
      userEmailMap.put(u.getAdresses().getEmail(), -1);
    }
    // one of the old OM version created 2 nodes "deleted" this code block handles this
    for (int i = 0; i < nl.getLength(); ++i) {
      Node user = nl.item(i);
      NodeList nl1 = user.getChildNodes();
      boolean deletedFound = false;
      for (int j = 0; j < nl1.getLength(); ++j) {
        Node node = nl1.item(j);
        if (node.getNodeType() == Node.ELEMENT_NODE && "deleted".equals(node.getNodeName())) {
          if (deletedFound) {
            user.removeChild(node);
            break;
          }
          deletedFound = true;
        }
      }
    }
   
    StringWriter sw = new StringWriter();
    Transformer xformer = TransformerFactory.newInstance().newTransformer();
        xformer.transform(new DOMSource(doc), new StreamResult(sw));
       
    List<User> list = new ArrayList<User>();
    InputNode root = NodeBuilder.read(new StringReader(sw.toString()));
    InputNode root1 = NodeBuilder.read(new StringReader(sw.toString())); //HACK to handle Address inside user
    InputNode root2 = NodeBuilder.read(new StringReader(sw.toString())); //HACK to handle old om_time_zone
    InputNode listNode = root.getNext();
    InputNode listNode1 = root1.getNext(); //HACK to handle Address inside user
    InputNode listNode2 = root2.getNext(); //HACK to handle old om_time_zone
    if (listNodeName.equals(listNode.getName())) {
      InputNode item = listNode.getNext();
      InputNode item1 = listNode1.getNext(); //HACK to handle Address inside user
      InputNode item2 = listNode2.getNext(); //HACK to handle old om_time_zone
      while (item != null) {
        User u = ser.read(User.class, item, false);
       
        boolean needToSkip1 = true;
        //HACK to handle Address inside user
        if (u.getAdresses() == null) {
          Address a = ser.read(Address.class, item1, false);
          u.setAdresses(a);
          needToSkip1 = false;
        }
        if (needToSkip1) {
          do {
View Full Code Here

    this.externalUserType = externalUserType;
  }

  public String toXml() throws Exception {
    StringWriter sw = new StringWriter();
    Serializer serializer = new Persister();
    serializer.write(this, sw);
    return sw.toString();
  }
View Full Code Here

    serializer.write(this, sw);
    return sw.toString();
  }

  public static RemoteSessionObject fromXml(String xml) {
    Serializer serializer = new Persister();
    try {
      return serializer.read(RemoteSessionObject.class, new StringReader(xml));
    } catch (Exception e) {
      log.error("Unexpected error while restoring object from XML: " + xml, e);
    }
    return null;
  }
View Full Code Here

TOP

Related Classes of org.simpleframework.xml.Serializer

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.