Examples of org.simpleframework.xml.core.Persister

org.simpleframework.xml.core.Persister

    
  }


  public String description() {
    // Nullable
    Serializer serializer = new Persister();
    StringWriter sw = new StringWriter();


    try {
      serializer.write(this, sw);
    }
    catch (Exception e) {
      return null;
    }

View Full Code Here


    return sw.getBuffer().toString();
  }


  public static Level read(String name) throws Exception {
    Serializer serializer = new Persister();
    File source = new File(Level.path + name);
    Level lvl = serializer.read(Level.class, source);


    lvl.setOrigin(source);


    return lvl;
  }

View Full Code Here


    return lvl;
  }


  public static Level read(File file) throws Exception {
    Serializer serializer = new Persister();
    Level lvl = serializer.read(Level.class, file);


    lvl.setOrigin(file);


    return lvl;
  }

View Full Code Here

    return lvl;
  }


  public boolean save() throws Exception {
    if (this.origin != null) {
      Serializer serializer = new Persister();


      serializer.write(this, this.origin);


      return true;
    }
    else return false;
  }

View Full Code Here

    }
    else return false;
  }


  public void saveAs(File f) throws Exception {
    Serializer serializer = new Persister();


    serializer.write(this, f);
  }

View Full Code Here


    serializer.write(this, f);
  }


  public void saveAs(String s) throws Exception {
    Serializer serializer = new Persister();
    File f = new File(Level.path + s);


    serializer.write(this, f);
  }

View Full Code Here

      return;
    }
    
    try {
      File reportFile = new File(dir, "TEST-" + displayName + ".xml");
      Persister persister = new Persister();
      persister.write(buildModel(e), reportFile);
    } catch (Exception x) {
      junit4.log("Could not serialize report for suite "
          + displayName + ": " + x.toString(), Project.MSG_WARN);
    }
  }

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.isDeleted()) {
          continue;
        }
        Configuration cfg = configurationDao.forceGet(c.getConf_key());
        if (cfg != null && !cfg.isDeleted()) {
          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

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.simpleframework.xml.core.Persister

cc.concurrent.config.client.Config

cc.concurrent.config.client.loader.Loader

com.anthavio.httl.inout.SimpleXmlExtractorFactory

com.anthavio.httl.inout.SimpleXmlRequestMarshaller

com.carrotsearch.ant.tasks.junit4.listeners.antxml.AntXmlReport

com.carrotsearch.ant.tasks.junit4.TestXmlStringsRoundtrip

com.commsen.jwebthumb.simplexml.SimpleXmlSerializer

com.politikodrom.parking.engine.Level

de.dfki.km.text20.browserplugin.services.sessionrecorder.impl.plainxml.SessionRecordImpl

net.alteiar.newversion.server.document.DocumentIO

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.