/*
* Copyright 2001-2004 The Apache Software Foundation.
*
* 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.
*/
package org.apache.juddi.function;
import java.util.Vector;
import org.apache.juddi.datatype.CategoryBag;
import org.apache.juddi.datatype.IdentifierBag;
import org.apache.juddi.datatype.RegistryObject;
import org.apache.juddi.datatype.binding.BindingTemplate;
import org.apache.juddi.datatype.binding.BindingTemplates;
import org.apache.juddi.datatype.business.BusinessEntity;
import org.apache.juddi.datatype.request.ValidateValues;
import org.apache.juddi.datatype.response.DispositionReport;
import org.apache.juddi.datatype.response.Result;
import org.apache.juddi.datatype.service.BusinessService;
import org.apache.juddi.datatype.service.BusinessServices;
import org.apache.juddi.datatype.tmodel.TModel;
import org.apache.juddi.error.RegistryException;
import org.apache.juddi.registry.RegistryEngine;
import org.apache.juddi.util.Config;
/**
* @author Steve Viens (sviens@apache.org)
*/
public class ValidateValuesFunction extends AbstractFunction
{
/**
*
*/
public ValidateValuesFunction(RegistryEngine registry)
{
super(registry);
}
/**
*
* @param obj
* @return RegistryObject
* @throws RegistryException
*/
public RegistryObject execute(RegistryObject obj)
throws RegistryException
{
ValidateValues request = (ValidateValues)obj;
String generic = request.getGeneric();
Vector businessVector = request.getBusinessEntityVector();
if ((businessVector != null) && (businessVector.size() > 0))
validateBusinessVector(businessVector);
Vector serviceVector = request.getBusinessServiceVector();
if ((serviceVector != null) && (serviceVector.size() > 0))
validateServiceVector(serviceVector);
Vector tModelVector = request.getTModelVector();
if ((tModelVector != null) && (tModelVector.size() > 0))
validateTModelVector(tModelVector);
// We don't currently support thh validate_values
// function so to keep things moving along let's
// just return a successful DispositionReport.
// We didn't encounter any problems so let's create an
// E_SUCCESS Result, embed it in a DispositionReport
// and return it.
Result result = new Result(Result.E_SUCCESS);
result.setErrCode(Result.lookupErrCode(Result.E_SUCCESS));
DispositionReport dispRpt = new DispositionReport();
dispRpt.setGeneric(generic);
dispRpt.setOperator(Config.getOperator());
dispRpt.addResult(result);
return dispRpt;
}
/**
*
*/
private RegistryObject validateBusinessVector(Vector businessVector)
{
if (businessVector == null)
return null;
for (int i=0; i<businessVector.size(); i++)
{
BusinessEntity business = (BusinessEntity)businessVector.elementAt(i);
CategoryBag catBag = business.getCategoryBag();
if (catBag != null)
{
Vector refs = catBag.getKeyedReferenceVector();
if ((refs != null) && (refs.size() > 0))
validate(refs);
}
IdentifierBag idBag = business.getIdentifierBag();
if (idBag != null)
{
Vector refs = idBag.getKeyedReferenceVector();
if ((refs != null) && (refs.size() > 0))
validate(refs);
}
BusinessServices services = business.getBusinessServices();
if (services != null)
{
Vector serviceVector = services.getBusinessServiceVector();
if (serviceVector != null)
validateServiceVector(serviceVector);
}
}
return null;
}
/**
*
*/
private RegistryObject validateServiceVector(Vector serviceVector)
{
if (serviceVector == null)
return null;
for (int i=0; i<serviceVector.size(); i++)
{
BusinessService service = (BusinessService)serviceVector.elementAt(i);
CategoryBag catBag = service.getCategoryBag();
if (catBag != null)
{
Vector refs = catBag.getKeyedReferenceVector();
if ((refs != null) && (refs.size() > 0))
validate(refs);
}
BindingTemplates templates = service.getBindingTemplates();
if (templates != null)
{
Vector bindings = templates.getBindingTemplateVector();
if (bindings != null)
validateBindingVector(bindings);
}
}
return null;
}
/**
*
*/
private RegistryObject validateBindingVector(Vector bindingVector)
{
if (bindingVector == null)
return null;
for (int i=0; i<bindingVector.size(); i++)
{
BindingTemplate binding = (BindingTemplate)bindingVector.elementAt(i);
CategoryBag catBag = binding.getCategoryBag();
if (catBag != null)
{
Vector refs = catBag.getKeyedReferenceVector();
if ((refs != null) && (refs.size() > 0))
validate(refs);
}
}
return null;
}
/**
*
*/
private RegistryObject validateTModelVector(Vector tModelVector)
{
if (tModelVector == null)
return null;
for (int i=0; i<tModelVector.size(); i++)
{
TModel tModel = (TModel)tModelVector.elementAt(i);
CategoryBag catBag = tModel.getCategoryBag();
if (catBag != null)
{
Vector refs = catBag.getKeyedReferenceVector();
if ((refs != null) && (refs.size() > 0))
validate(refs);
}
IdentifierBag idBag = tModel.getIdentifierBag();
if (idBag != null)
{
Vector refs = idBag.getKeyedReferenceVector();
if ((refs != null) && (refs.size() > 0))
validate(refs);
}
}
return null;
}
/**
*
* @param args
*/
private RegistryObject validate(Vector refs)
{
if (refs == null)
return null;
for (int i=0; i<refs.size(); i++)
{
//KeyedReference ref = (KeyedReference)refs.elementAt(i);
// Perform the validation
}
return null;
}
/***************************************************************************/
/***************************** TEST DRIVER *********************************/
/***************************************************************************/
public static void main(String[] args)
{
// initialize the registry
RegistryEngine reg = new RegistryEngine();
reg.init();
try
{
}
catch (Exception ex)
{
// write execption to the console
ex.printStackTrace();
}
finally
{
// destroy the registry
reg.dispose();
}
}
}