<?xml version="1.0" encoding="UTF-8"?>
<!--

    Copyright (C) 2015 ZTE, Inc. and others. All rights reserved. (ZTE)

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

            http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.

-->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
      <groupId>org.openo.oparent</groupId>
      <artifactId>oparent</artifactId>
      <version>1.0.0-SNAPSHOT</version>
      <relativePath></relativePath>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.openo.gso.gui</groupId>
    <artifactId>gso-gui</artifactId>
    <packaging>pom</packaging>
    <name>gui</name>
    <modules>
        <module>openo-portal</module>
        <module>servicegateway</module>
    </modules>
</project>
