Examples of com.opengamma.master.position.ManageablePosition

com.opengamma.master.position.ManageablePosition
A position held in a position master.
A position is fundamentally a quantity of a security. For example, a position might be 50 shares of OpenGamma.
Positions are formed from a set of trades, however trade data may not always be available or complete. Even if trade data is available, the position details cannot necessarily be derived from the trades. Therefore the position holds the quantity and security reference directly, separately from the underlying trades.
Positions are logically attached to nodes in the portfolio tree, however they are stored and returned separately from the position master.

    assertTrue(storedDoc.getPosition().getTrades().contains(trade2));
  }


  @Test
  public void test_getTradePosition_withAttributes() {
    final ManageablePosition position = new ManageablePosition(BigDecimal.TEN, ExternalId.of("A", "B"));


    final LocalDate tradeDate = _now.toLocalDate();
    final OffsetTime tradeTime = _now.toOffsetTime().minusSeconds(500);


    final ManageableTrade trade1 = new ManageableTrade(BigDecimal.TEN, ExternalId.of("A", "B"), tradeDate, tradeTime, ExternalId.of("CPS", "CPV"));
    trade1.addAttribute("key11", "Value11");
    trade1.addAttribute("key12", "Value12");
    position.getTrades().add(trade1);


    final ManageableTrade trade2 = new ManageableTrade(BigDecimal.TEN, ExternalId.of("C", "D"), tradeDate, tradeTime, ExternalId.of("CPS2", "CPV2"));
    trade2.addAttribute("key21", "Value21");
    trade2.addAttribute("key22", "Value22");
    position.getTrades().add(trade2);


    final PositionDocument doc = new PositionDocument();
    doc.setPosition(position);
    _posMaster.add(doc);
    assertNotNull(trade1.getUniqueId());
    assertNotNull(trade2.getUniqueId());


    assertEquals(trade1, _posMaster.getTrade(trade1.getUniqueId()));
    assertEquals(trade2, _posMaster.getTrade(trade2.getUniqueId()));


    final PositionDocument storedDoc = _posMaster.get(position.getUniqueId());
    assertNotNull(storedDoc);
    assertNotNull(storedDoc.getPosition());
    assertNotNull(storedDoc.getPosition().getTrades());
    assertEquals(2, storedDoc.getPosition().getTrades().size());
    assertTrue(storedDoc.getPosition().getTrades().contains(trade1));

View Full Code Here

    }
    return trade;
  }


  private ManageablePosition createPosition(final ManageableSecurity security) {
    final ManageablePosition position = new ManageablePosition(BigDecimal.ONE, getBundle(security));
    position.addTrade(createTrade(security));
    return position;
  }

View Full Code Here

  }
  
  private ManageablePortfolioNode createNode(final String nodeName, final Collection<? extends ManageableSecurity> securities) {
    final ManageablePortfolioNode node = new ManageablePortfolioNode(nodeName);
    for (ManageableSecurity security : securities) {
      final ManageablePosition position = createPosition(security);
      node.addPosition(_positions.add(new PositionDocument(position)).getObjectId());
    }
    return node;
  }

View Full Code Here

  private PortfolioPosition createPortfolioPosition(Trade trade, ManageableSecurity[] security, String[] parentPath) {
    return new PortfolioPosition(convertTradeToPosition(trade, security[0]), security, parentPath);
  }


  private ManageablePosition convertTradeToPosition(Trade trade, ManageableSecurity security) {
    ManageablePosition manageablePosition = new ManageablePosition(trade.getQuantity(), security.getExternalIdBundle());
    manageablePosition.addTrade(convertTrade(trade, security));
    return manageablePosition;
  }

View Full Code Here

  private ManageablePosition convertPosition(Position position, Security security, BigDecimal tradeQuantity) {


    // If the position is supplying a quantity, then we should use that
    // rather than the total quantity obtained from the trades
    BigDecimal positionQuantity = position.getQuantity();
    ManageablePosition manageablePosition = new ManageablePosition(
        positionQuantity != null ? positionQuantity : tradeQuantity, security.getExternalIdBundle());


    IdWrapper externalSystemId = position.getExternalSystemId();
    if (externalSystemId != null) {
      manageablePosition.setProviderId(externalSystemId.toExternalId());
    }


    List<Trade> trades = position.getTrades();
    for (Trade trade : nullCheckIterable(trades)) {
      manageablePosition.addTrade(convertTrade(trade, security));
    }


    manageablePosition.setAttributes(position.getAdditionalAttributes());


    return manageablePosition;
  }

View Full Code Here

      final List<ExternalId> cdsArgs = newArrayList();




      final SecureRandom random = new SecureRandom();
      for (PositionDocument positionDocument : positions.values()) {
        ManageablePosition position = positionDocument.getValue();


        ManageableSecurityLink link = position.getSecurityLink();
        SecuritySearchRequest ssr = new SecuritySearchRequest();
        ssr.addExternalIds(link.getExternalIds());
        SecuritySearchResult securitySearchResult = getToolContext().getSecurityMaster().search(ssr);
        Security security = securitySearchResult.getFirstSecurity();
        //Security security = position.getSecurity();

View Full Code Here

    // If merging positions, check if any of the positions in the current node reference the same security id
    // and if so, just update the existing position and return
    if (_mergePositions && _securityIdToPosition.containsKey(writtenSecurities.get(0).getUniqueId().getObjectId())) {


      // Add new quantity to existing position's quantity
      final ManageablePosition existingPosition = _securityIdToPosition.get(writtenSecurities.get(0).getUniqueId().getObjectId());
      existingPosition.setQuantity(sumPositionQuantities(existingPosition, position));


      // Add new trades to existing position's trades
      for (ManageableTrade trade : position.getTrades()) {
        existingPosition.addTrade(trade);
      }


      if (!_multithread) {
        // Save the updated existing position to the position master
        PositionDocument addedDoc = _positionMaster.update(new PositionDocument(existingPosition));
        s_logger.debug("Updated position {}, delta position {}", addedDoc.getPosition(), position);


        // update position map (huh?)
        _securityIdToPosition.put(writtenSecurities.get(0).getUniqueId().getObjectId(), addedDoc.getPosition());


        // Return the updated position
        return new ObjectsPair<>(addedDoc.getPosition(),
            securities);
      } else {
        // update position map
        _securityIdToPosition.put(writtenSecurities.get(0).getUniqueId().getObjectId(), existingPosition);


         // Return the updated position
        return new ObjectsPair<>(existingPosition, securities);
      }
    }
    // Attempt to reuse an existing position from the previous version of the portfolio, and return if an exact match is found
    if (!(_originalNode == null) && !_originalNode.getPositionIds().isEmpty()) {
      ManageablePosition existingPosition = matchExistingPosition(position, writtenSecurities);
      if (existingPosition != null) {
        return new ObjectsPair<>(existingPosition,
            writtenSecurities.toArray(new ManageableSecurity[writtenSecurities.size()]));
      }
    }

View Full Code Here


    // TODO Compare position attributes


    PositionSearchResult searchResult = _positionMaster.search(searchReq);
    for (ManageablePosition existingPosition : searchResult.getPositions()) {
      ManageablePosition chosenPosition = null;
      if (writtenSecurities.get(0).getUniqueId().getObjectId().equals(existingPosition.getSecurityLink().getObjectId())) {
        chosenPosition = existingPosition;
      } else {
        for (ExternalId id : existingPosition.getSecurityLink().getExternalIds()) {
          if (writtenSecurities.get(0).getExternalIdBundle().contains(id) && existingPosition.getQuantity().equals(position.getQuantity())) {
            chosenPosition = existingPosition;
            break;
          }
        }
      }
      // Check for trade equality
      if (chosenPosition != null && (chosenPosition.getTrades().size() == position.getTrades().size())) {


        for (ManageableTrade trade : chosenPosition.getTrades()) {


          ManageableTrade comparableTrade = JodaBeanUtils.clone(trade);
          comparableTrade.setUniqueId(null);
          if (!(position.getTrades().contains(comparableTrade))) {
            chosenPosition = null;
            break;
          }
        }


        // If identical, reuse the chosen position
        if (chosenPosition != null) {
          // Add the existing position to the portfolio
          _currentNode.addPosition(chosenPosition.getUniqueId());


          // Update position map
          _securityIdToPosition.put(writtenSecurities.get(0).getUniqueId().getObjectId(), chosenPosition);


          // return existing position

View Full Code Here


      // If keeping original portfolio nodes and merging positions, populate position map with existing positions in node
      if (_keepCurrentPositions && _mergePositions && _originalNode != null) {
        s_logger.debug("Storing security associations for positions " + _originalNode.getPositionIds() + " at path " + StringUtils.join(newPath, '/'));
        for (ObjectId positionId : _originalNode.getPositionIds()) {
          ManageablePosition position = null;
          try {
            position = _positionMaster.get(positionId, VersionCorrection.LATEST).getPosition();
          } catch (Exception e) {
            // no action
            s_logger.error("Exception retrieving position " + positionId, e);
          }
          if (position != null) {
            position.getSecurityLink().resolve(_securitySource);
            if (position.getSecurity() != null) {
              if (_securityIdToPosition.containsKey(position.getSecurity())) {
                ManageablePosition existing = _securityIdToPosition.get(position.getSecurity());
                s_logger.warn("Merging positions but found existing duplicates under path " + StringUtils.join(newPath, '/') + ": " + position + " and " + existing
                    + ".  New trades for security " + position.getSecurity().getUniqueId().getObjectId() + " will be added to position " + position.getUniqueId());
              
              } else {
                _securityIdToPosition.put(position.getSecurity().getUniqueId().getObjectId(), position);

View Full Code Here

      return "Example";
    }
  }


  private ManageablePosition createPosition(ManageableSecurity security, boolean includeTrade) {
    ManageablePosition position = new ManageablePosition(BigDecimal.ONE, security.getExternalIdBundle());
    if (includeTrade) {
      ManageableTrade trade = new ManageableTrade(BigDecimal.ONE, security.getExternalIdBundle(), LocalDate.now().minusDays(3), OffsetTime.now(), ExternalId.of("Cpty", "GOLDMAN"));
      position.addTrade(trade);
    }
    return position;
  }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of com.opengamma.master.position.ManageablePosition

com.opengamma.core.position.impl.SimplePosition

com.opengamma.examples.bloomberg.loader.DemoEquityOptionCollarPortfolioLoader

com.opengamma.examples.bloomberg.loader.ExampleAUDSwapPortfolioLoader

com.opengamma.examples.bloomberg.loader.ExampleBondPortfolioLoader

com.opengamma.examples.bloomberg.loader.ExampleEquityPortfolioLoader

com.opengamma.examples.bloomberg.loader.ExampleEURFixedIncomePortfolioLoader

com.opengamma.examples.bloomberg.loader.ExampleFxForwardPortfolioLoader

com.opengamma.examples.bloomberg.loader.ExampleMixedCMCapFloorPortfolioLoader

com.opengamma.examples.bloomberg.loader.ExampleMultiCurrencySwapPortfolioLoader

com.opengamma.examples.bloomberg.loader.ExampleSwaptionPortfolioLoader

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.