Exemplo n.º 1
0
  public void saveServiceDefinition(String serviceId) {

    Resource serviceDefFile = getServiceDefXml(serviceId, false);
    Service service = getCurrentServiceDefinition(serviceId);

    Service oldService = null;
    if (serviceId.equals(CommonConstants.SALESFORCE_SERVICE)) {
      // For salesforceService, we need to retain service definitions in
      // the old service definition file.
      oldService = loadServiceDefinition(serviceId);

      if (oldService != null) {
        for (Operation op : oldService.getOperation()) {
          if (isDeletedQuery(op)) {
            this.cfg.removeDeletedSFQueries(op.getName());
            continue;
          }
          service.addOperation(op);
        }

        List<DataObject> dataObjects = service.getDataobjects().getDataobject();
        for (DataObject dobj : oldService.getDataobjects().getDataobject()) {
          if (isDeletedSFDataObject(dobj)) {
            this.cfg.removeDeletedSFDataObjects(dobj.getName());
            continue;
          }
          dataObjects.add(dobj);
        }

        service.setType(oldService.getType());
        service.setCRUDService(oldService.getCRUDService());
      }
    } // salesforce
    try {
      Marshaller marshaller = definitionsContext.createMarshaller();
      marshaller.setProperty("jaxb.formatted.output", true);
      OutputStream outputStream = this.fileSystem.getOutputStream(serviceDefFile);
      try {
        marshaller.marshal(service, outputStream);
      } finally {
        try {
          outputStream.close();
        } catch (IOException e) {
          throw new IllegalStateException("Unable to close service def file", e);
        }
      }
      // XXX MAV-569 should do a real build here, or actually outside
      // this method maybe
      SortedSet<Service> s = new TreeSet<Service>(new ServiceComparator());
      s.add(service);
      generateRuntimeConfiguration(s);
    } catch (JAXBException e) {
      throw new WMRuntimeException(e);
    } catch (IOException e) {
      throw new WMRuntimeException(e);
    } catch (NoSuchMethodException e) {
      throw new WMRuntimeException(e);
    }
  }
Exemplo n.º 2
0
  /** Return the operation for the passed name, or null if it doesn't exist. */
  public Operation getOperation(String serviceId, String name) {

    Service service = getCurrentServiceDefinition(serviceId);
    for (Operation operation : service.getOperation()) {
      if (operation.getName().equals(name)) {
        return operation;
      }
    }
    return null;
  }
Exemplo n.º 3
0
  // -----------------------------------------------------------------------
  // internal ops
  // -----------------------------------------------------------------------
  protected void doUpdateOperation(
      ServiceOperation so,
      Service service,
      ServiceDefinition sd,
      IPwsServiceModifier serviceModifier) {

    List<Operation> ops = service.getOperation();

    Operation op = null;
    for (Operation opTemp : ops) {
      if (opTemp.getName().equals(so.getName())) {
        op = opTemp;
        break;
      }
    }
    if (op == null) {
      op = new Operation();
      op.setName(so.getName());
      ops.add(op);
    }

    List<Operation.Parameter> params = op.getParameter();

    if (params.size() > 0) {
      params.clear();
    }

    for (FieldDefinition input : so.getParameterTypes()) {
      Operation.Parameter param = new Operation.Parameter();
      param.setIsList(input.getDimensions() > 0);
      param.setName(input.getName());
      if (input.getTypeDefinition() != null) {
        param.setTypeRef(input.getTypeDefinition().getTypeName());
      }
      params.add(param);
    }

    if (so.getReturnType() != null) {
      Operation.Return ret = new Operation.Return();
      FieldDefinition retType;
      if (serviceModifier == null) {
        retType = so.getReturnType();
      } else {
        retType = serviceModifier.getOperationReturnType(so);
      }

      ret.setIsList(retType.getDimensions() > 0);
      if (retType.getTypeDefinition() != null) {
        ret.setTypeRef(retType.getTypeDefinition().getTypeName());
      }
      op.setReturn(ret);

      op.setOperationType(so.getOperationType());
    }
  }
Exemplo n.º 4
0
  /**
   * Return a list of all operations registered with a given service.
   *
   * @param serviceId The service to examine.
   * @return
   */
  public List<String> getOperationNames(String serviceId) {

    Service service = getCurrentServiceDefinition(serviceId);
    List<Operation> operations = service.getOperation();
    List<String> ret = new ArrayList<String>(operations.size());
    for (Operation op : operations) {
      ret.add(op.getName());
    }

    return ret;
  }
Exemplo n.º 5
0
  /**
   * Define the definition of a service; this will destroy any existing configuration associated
   * with the serviceid.
   *
   * @param serviceDef The service definition for the newly defined service.
   */
  @SuppressWarnings("deprecation")
  public void defineService(ServiceDefinition serviceDef, String username, String password) {

    try {
      validateServiceId(serviceDef.getServiceId());
    } catch (DuplicateServiceIdException ignore) {
      // ignore
    }

    Service oldService = getService(serviceDef.getServiceId());

    Service service = new Service();

    /** Copying the service operations to the new service */
    if (serviceDef instanceof AbstractDeprecatedServiceDefinition) {
      // List<String> opNames =
      // ((AbstractDeprecatedServiceDefinition)serviceDef).getOperationNames();
      if (oldService != null) {
        List<Operation> ops = oldService.getOperation();
        if (ops != null) {
          for (Operation op : ops) {
            // if(opNames != null && opNames.contains(op.getName())){
            service.addOperation(op);
            // }
          }
        }
      }
    }

    getCurrentServiceDefinitions().put(serviceDef.getServiceId(), service);

    IPwsServiceModifier serviceModifier;
    if (this.pwsServiceModifierBeanFactory == null || serviceDef.getPartnerName() == null) {
      serviceModifier = null;
    } else {
      serviceModifier =
          this.pwsServiceModifierBeanFactory.getPwsServiceModifier(serviceDef.getPartnerName());
    }

    try {
      for (ServiceOperation op : serviceDef.getServiceOperations(serviceModifier)) {
        doUpdateOperation(op, service, serviceDef, serviceModifier);
      }
      service.setId(serviceDef.getServiceId());
      service.setType(serviceDef.getServiceType().getTypeName());
      service.setCRUDService(serviceDef.isLiveDataService());
      if (serviceDef instanceof ReflectServiceDefinition) {
        service.setClazz(((ReflectServiceDefinition) serviceDef).getServiceClass());
      }

      if (serviceDef.getRuntimeConfiguration() != null) {
        service.setSpringFile(serviceDef.getRuntimeConfiguration());
      } else if (oldService != null && oldService.getSpringFile() != null) {
        service.setSpringFile(oldService.getSpringFile());
      }

      updateServiceTypes(service, serviceDef, username, password);
    } catch (WMRuntimeException e) {
      // if we had an error, remove the service def so we'll use the last
      // known-good one
      getCurrentServiceDefinitions().remove(serviceDef.getServiceId());
      throw e;
    }

    String svcId = service.getId();
    // TODO: Skipping salesforce setup when null is passed in for username
    // is not good programming practice.
    // TODO: The logic has to be rewritten later when we have time.
    if (svcId.equals(CommonConstants.SALESFORCE_SERVICE) && username != null) { // salesforce
      SalesforceHelper.setupSalesforceSrc(this.projectManager, username, password);
    }

    defineService(service);
  }