private void CreateResourceContract(OfferedResource offeredResource) {

    // the contracts...to be used later on resource advisor

    // add a dummy  contract between one service and one exact resource (but multiton..we can
    // instantiate a lot of them )
    Cost cost = AvailabilityContractFactory.eINSTANCE.createCost();

    Random generator = new Random();
    cost.setAmount((double) generator.nextInt(10) / 20 + (double) generator.nextInt(10) / 20);
    cost.setPerUnit(brokermodel.availabilityContract.costUnit.HOUR);

    //		costUnit unit = AvailabilityContractFactory.eINSTANCE.;
    //		cost.setPerUnit(unit );

    Availability availability = AvailabilityContractFactory.eINSTANCE.createAvailability();
    availability.setCost(cost);
    Calendar rightNow = Calendar.getInstance();
    Date fromdate = rightNow.getTime();
    availability.setFromDate(fromdate);
    rightNow.add(Calendar.MONTH, 36);
    Date todate = rightNow.getTime();
    availability.setToDate(todate);

    ResourceServiceContract contract =
        AvailabilityContractFactory.eINSTANCE.createResourceServiceContract();

    contract.setAvailability(availability);
    contract.setDescription(
        "a contract between service "
            + offeredResource.getImplOfferedService().getName()
            + " and offered resource "
            + offeredResource.getName()
            + ", offered by site "
            + offeredResource.getBelongsToSite().getName()
            + " of provider "
            + offeredResource.getBelongsToSite().getBelongsToProvider().getName());
    contract.setForOfferedResource(offeredResource);
    contract.setForOfferedService(offeredResource.getImplOfferedService());
    contract.setStartDate(fromdate);
    contract.setEndDate(todate);

    broker.getResourceServiceContracts().add(contract);

    contract.setId(broker.getResourceServiceContracts().size());
    contract.setUniqueID("contr_" + broker.getResourceServiceContracts().size());
    contract.setName(
        "C"
            + broker.getResourceServiceContracts().size()
            + "_"
            + offeredResource.getName()
            + "_"
            + offeredResource.getImplOfferedService().getName());
  }
  /**
   * @param resSpecID
   * @return the OfferedService having the given ID
   * @author ctranoris
   */
  private OfferedService FindOfferedServiceFromName(String resName) {
    // we can search for the proper service  by browsing
    for (int i = 0; i < broker.getOfferedServices().size(); i++) {
      if (broker.getOfferedServices().get(i).getName().equalsIgnoreCase(resName)) {
        log("FindOfferedServiceFromName offServ=" + resName + ", exists!");
        return broker.getOfferedServices().get(i);
      }
    }

    return null;
  }
  /**
   * Initializes the Office model
   *
   * @author ctranoris
   */
  private void InitModel() {

    // create a temporary office
    broker = BrokermodelFactory.eINSTANCE.createBroker();
    broker.setName(this.authorizationKey.getCredentials().getCredoptions().get(SFAUtils.USERNAME));
    broker.setAPIGateway(
        this.authorizationKey.getCredentials().getCredoptions().get(SFAUtils.SM_URL));

    // create a taxonomy
    generalTaxonomy = ServicesFactory.eINSTANCE.createTaxonomy();
    generalTaxonomy.setName("General");
    broker.getContributedTaxonomies().add(generalTaxonomy);
    generalTaxonomy.getTaxonomies().add(ServicesFactory.eINSTANCE.createTaxonomy());
    generalTaxonomy.getTaxonomies().get(0).setName("General Services");

    BrokerCustomer officeUser = UsersFactory.eINSTANCE.createBrokerCustomer();
    broker.getRegisteredUsers().add(officeUser);
    Account account = UsersFactory.eINSTANCE.createAccount();
    account.setAuthorizationKey(authorizationKey);
    officeUser.setHasAccount(account);
  }
  public void TranformModel() {
    InitModel();

    String rspec = client.ListResources();

    System.out.println(rspec);
    System.out.println("=======================================================================");
    if (rspec.equals("")) return;

    Document resourceSpecDocument = xmlutl.getXMLDocFromString(rspec);

    // NodeList aggregates = xmlutl.getNodeListFromObject(resourceSpecDocument, "//aggregate");

    NodeList networks = xmlutl.getNodeListFromObject(resourceSpecDocument, "//network");

    if (networks == null) return;

    for (int ixOrgan = 0; ixOrgan < networks.getLength(); ixOrgan++) {
      Node network = networks.item(ixOrgan);
      // String organName = xmlutl.getNodeValueFromObject( item, "name/text()" );
      // String organID = xmlutl.getNodeValueFromObject( organisationSpecNodes.item(ixOrgan), "@id"
      // );
      String organName = xmlutl.getNodeValueFromObject(network, "@name");
      String organID = organName; // will be the same
      System.out.println(organName);

      ResourcesProvider resourcesProvider;
      Site partnerSite;
      // create the partner
      resourcesProvider = UsersFactory.eINSTANCE.createResourcesProvider();
      broker.getRegisteredUsers().add(resourcesProvider);
      log("officePartner organID: " + organID);
      resourcesProvider.setId(ixOrgan);
      resourcesProvider.setUniqueID("rp" + organID);
      organName = organName.trim();
      log("resourcesProvider organName: " + organName);
      resourcesProvider.setName(
          organName); // we set the name also later in the ptm Name, to have something shorter!
      resourcesProvider.setDescription(organName);
      resourcesProvider.setOrganization(organName);
      partnerSite = ProvidersiteFactory.eINSTANCE.createSite();
      partnerSite.setId(0);
      partnerSite.setUniqueID(resourcesProvider.getUniqueID() + "_s" + organID);
      partnerSite.setName("site");
      resourcesProvider.getOfferedSiteList().add(partnerSite);
      partnerSite.setBelongsToProvider(resourcesProvider);

      // Add now the PTM for the site
      DomainManager ptm = ProvidersiteFactory.eINSTANCE.createDomainManager();
      partnerSite.setDomainManager(ptm);

      ptm.setBelongsToSite(partnerSite);
      NodeList resourceSpecNodes =
          xmlutl.getNodeListFromObject(
              resourceSpecDocument, "//network[@name=\"" + organName + "\"]/node");

      // String organName = xmlutl.getNodeValueFromObject( item, "name/text()" );
      // String organID = xmlutl.getNodeValueFromObject( organisationSpecNodes.item(ixOrgan), "@id"
      // );
      for (int ixNode = 0; ixNode < resourceSpecNodes.getLength(); ixNode++) {

        Node resNode = resourceSpecNodes.item(ixNode);
        // SFA mainly offers nodes?!
        CreateOfferedService_Resource_Contract(
            "node",
            partnerSite,
            resNode,
            true); // we can toggle this false if we will create OfferedResources only from ptmInfo
      }
    }

    // slices should be also added as resources/offered services.
    // And each node will have a setting called sliver that the user can
    // assign the slice name..
    // Slices can be added to a different taxonomy

  }
  private void CreateOfferedService_Resource_Contract(
      String serviceName, Site partnerSite, Node resNode, Boolean createResource) {

    String resourceName = xmlutl.getNodeValueFromObject(resNode, "@component_name");
    log("resourceName : " + resourceName);
    String resourceSpecID = xmlutl.getNodeValueFromObject(resNode, "@component_id");

    if (resourceName.equals("")) {
      resourceName = xmlutl.getNodeValueFromObject(resNode, "hostname/text()");
    }

    //		NodeList resourceSpecNodes = xmlutl.getNodeListFromObject( resourceSpecDocument,
    // "//resourceSpec [@id="+resourceSpecID+"]");
    String offeredServiceName = serviceName;

    log("offeredService offeredServiceName: " + offeredServiceName);
    String offeredServiceDescr = "sfa " + offeredServiceName;
    //		//add back these for the service settings
    //		String configParamCompositeId = xmlutl.getNodeValueFromObject(resourceSpecNodes.item(0),
    // "configurationParameters/@id");
    //		log("configParamCompositeId offServ="+offeredServiceName+", configParamCompositeId
    // ="+configParamCompositeId);
    //
    //		//before creating the service, check if exists
    Boolean newServiceCreated = false;

    //		OfferedService offService = FindOfferedServiceFromID(  resourceSpecID );
    //		if (offService==null)
    OfferedService offService = FindOfferedServiceFromName(offeredServiceName);

    if (offService == null) {
      offService = ServicesFactory.eINSTANCE.createOfferedService();
      offService.setId(0); // not used in SFA?!
      //			offService.setUniqueID("os"+Integer.parseInt(resourceSpecID));
      offService.setUniqueID("os" + offeredServiceName);
      offService.setName(offeredServiceName);

      // offService.setDefaultValue();
      offService.setDescription(offeredServiceDescr);
      log("offeredService offeredServiceDescr: " + offeredServiceDescr);
      broker.getOfferedServices().add(offService);
      newServiceCreated = true;
    }

    // IF <configParamType>reference</configParamType> can be assigned

    // add the service as offered Resource also of Partner...a Contract must be also created here!
    OfferedResource offeredResource = null;
    if (createResource) {
      offeredResource = ResourcesFactory.eINSTANCE.createOfferedResource();
      partnerSite.getOfferedResourcesList().add(offeredResource);
      offeredResource.setBelongsToSite(partnerSite);
      offeredResource.setId(0); // not used in SFA?!
      offeredResource.setUniqueID(resourceName);
      //			String prefix="";
      //			if ((partnerSite.getPtm() != null) && (partnerSite.getPtm().getName() != null))
      //				prefix = partnerSite.getPtm().getName();
      offeredResource.setName(
          resourceName); // in SFA seems node names are unique//Will replace . with _
      offeredResource.setDescription(offeredServiceDescr);
      offeredResource.setImplOfferedService(offService);
      offeredResource.setMultitonMaxOccur(
          1); // we have atleast one of these resources to be reserved

      int prefix = partnerSite.getBelongsToProvider().getId();

      offeredResource.setGeocoords("-170, 50");

      CreateResourceContract(offeredResource);
    }

    CreateSetting(
        "hostname",
        "defvalHostNameSet",
        "node hostname",
        newServiceCreated,
        offService,
        offeredResource,
        true,
        false,
        true);
    CreateSetting(
        "vsys",
        "",
        "request access to a vsys script on the selected node",
        newServiceCreated,
        offService,
        offeredResource,
        true,
        true,
        true);
    CreateSetting(
        "initscript",
        "",
        "initscript on the selected node",
        newServiceCreated,
        offService,
        offeredResource,
        true,
        true,
        true);
    CreateSetting(
        "vsys_vnet",
        "",
        "initscript on the selected node",
        newServiceCreated,
        offService,
        offeredResource,
        true,
        true,
        true);

    // Finally add service to the general ServiceCategories
    generalTaxonomy.getTaxonomies().get(0).getHasServices().add(offService);
  }