private IEnumerable <CoreClassifier> getEnumerations(CoreModelImpl model)
{
var enumStereotype =
(CoreStereotypeImpl)
model.getAllStereotypes().FirstOrDefault(s => ((CoreStereotypeImpl)s).getName().Equals("Enumeration"));
return(enumStereotype != null?enumStereotype.getExtendedElement().Cast <CoreClassifier>().ToList() : new List <CoreClassifier>());
}
/// <summary>
/// Retorna todas as classes existente em um determinado modelo
/// </summary>
/// <param name="model">modelo</param>
/// <returns></returns>
private IEnumerable <CoreClassifier> getClasses(CoreModelImpl model)
{
var classes = environment.getAllOfType(typeof(CoreClassifierImpl));
List <CoreClassifier> realClasses = new List <CoreClassifier>();
foreach (CoreClassifierImpl classifier in classes)
{
if (!model.isPrimitiveType(classifier) && !classifier.isEnumeration() && !(classifier is CoreDataTypeImpl))
{
realClasses.Add(classifier);
}
}
return(realClasses);
}
public CoreModel getModel(XNamespace xnamespace)
{
if (coreModel != null)
{
return(coreModel);
}
xcoreModel = doc.Element(xnamespace + "logicalClassDesignerModel");
if (xcoreModel != null)
{
coreModel = new CoreModelImpl();
var name = xcoreModel.Attribute("name");
coreModel.setName(name != null ? name.Value : "");
var xcoreModelNamespace = xcoreModel.Element(xnamespace + "packagedElements");
if (xcoreModelNamespace != null)
{
CoreNamespace coreNamespace = new CoreNamespaceImpl();
var xhaspackages = xcoreModelNamespace.Element(xnamespace + "logicalClassDesignerModelHasPackages");
if (xhaspackages != null)
{
var xpackages = xhaspackages.Elements(xnamespace + "package");
// all model datatypes
var xdatatypes = xcoreModelNamespace.Descendants(xnamespace + "referencedType");
foreach (var xdatatype in xdatatypes.Where(x => !belongsPackages(x, xpackages)))
{
createDataType(coreNamespace, coreModel, xdatatype);
}
foreach (var xpackage in xpackages)
{
createPackage(xnamespace, coreNamespace, coreModel, xpackage);
}
}
// fill model types
fillModelElementTypes();
}
}
return(coreModel);
}
public CoreModel getModel(XNamespace xnamespace)
{
if (coreModel != null)
{
return(coreModel);
}
var xcoreModel = doc.Descendants(xnamespace + "Model").FirstOrDefault();
if (xcoreModel != null)
{
coreModel = new CoreModelImpl();
var xcoreModelNamespace = xcoreModel.Element(xnamespace + "Namespace.ownedElement");
if (xcoreModelNamespace != null)
{
CoreNamespace coreNamespace = new CoreNamespaceImpl();
// all model datatypes
var xdatatypes = xcoreModelNamespace.Descendants(xnamespace + "DataType");
foreach (var xdatatype in xdatatypes)
{
createDataType(coreNamespace, coreModel, xdatatype);
}
var xmodelClasses = xcoreModelNamespace.Elements(xnamespace + "Class");
createModelClasses(xnamespace, coreNamespace, coreModel, xmodelClasses);
var xpackages = xcoreModelNamespace.Elements(xnamespace + "Package");
foreach (var xpackage in xpackages)
{
createPackage(xnamespace, coreNamespace, coreModel, xpackage);
}
// all model generalizations
var xgeneralizations = getAllAvailableGeneralizations(xnamespace, xcoreModelNamespace);
foreach (var xgeneralization in xgeneralizations)
{
createGeneralization(xnamespace, xgeneralization);
}
// create all model abstractions
var xabstractions = xcoreModelNamespace.Descendants(xnamespace + "Abstraction");
foreach (var xabstraction in xabstractions)
{
createAbstraction(xabstraction);
}
// fill model types
fillModelElementTypes();
// all associations classes
var xassociationclasses = xcoreModelNamespace.Descendants(xnamespace + "AssociationClass");
foreach (var xassociationclass in xassociationclasses)
{
CoreAssociationClass associationClass = (CoreAssociationClass)createAssociation(xnamespace, xassociationclass, new CoreAssociationClassImpl());
fillModelElementTypes();
updateElemOwnedElements(coreModel, associationClass);
associationClass.setElemOwner(coreModel);
updateElemOwnedElements(coreModel, associationClass);
associationClass.setNamespace(coreNamespace);
updateNamespaceElemOwnedElements(coreNamespace, associationClass);
var xclassifierfeature = xassociationclass.Element(xnamespace + "Classifier.feature");
if (xclassifierfeature != null)
{
var xoperations = xclassifierfeature.Elements(xnamespace + "Operation");
foreach (var xoperation in xoperations)
{
createOperation(xnamespace, coreNamespace, associationClass, xoperation);
}
var xattributes = xclassifierfeature.Elements(xnamespace + "Attribute");
foreach (var xattribute in xattributes)
{
createAttribute(coreNamespace, associationClass, xattribute);
}
}
}
// all model associations
var xassociations = xcoreModelNamespace.Descendants(xnamespace + "Association");
foreach (var xassociation in xassociations)
{
CoreAssociation coreAssociation = createAssociation(xnamespace, xassociation, new CoreAssociationImpl());
fillModelElementTypes();
//coreModel.addAssociation(coreAssociation);
updateElemOwnedElements(coreModel, coreAssociation);
}
}
}
return(coreModel);
}
/// <summary>
/// Cria colunas na tabela em questão para cada feature do classifier
/// </summary>
/// <param name="coreClassifier">classifier</param>
/// <param name="xDataTable">tabela</param>
/// <param name="model">modelo</param>
private void createFeatureColumns(CoreClassifier coreClassifier, XDataTable xDataTable, CoreModelImpl model)
{
List <object> features = new List <object>();
features.AddRange(coreClassifier.getClassifierFeatures().Where(f => f.GetType() == typeof(CoreAttributeImpl)));
var keyAttribute = features.FirstOrDefault(f => ((CoreAttributeImpl)f).hasStereotype("Id"));
if (keyAttribute != null)
{
xDataTable.setKeyIndex(features.IndexOf(keyAttribute) + 1);
}
features.AddRange(coreClassifier.getClassifierFeatures().Where(f => f.GetType() == typeof(CoreOperationImpl)));
foreach (CoreFeature feature in features)
{
XDataTableColumn xDataTableColumn = new XDataTableColumn();
xDataTableColumn.setName(feature.getName());
xDataTableColumn.setDataTable(xDataTable);
updateDataTable(xDataTable, xDataTableColumn);
if (feature is CoreAttributeImpl)
{
var featureImpl = (CoreAttributeImpl)feature;
string featureName = featureImpl.getFeatureType().getName();
if (coreClassifier.isEnumeration())
{
xDataTableColumn.setXReference(featureName);
}
else
{
var enumerations = getEnumerations(model);
if (enumerations.FirstOrDefault(e => e.getName() == featureName) != null)
{
xDataTableColumn.setXReference(featureName);
}
}
}
}
}
/// <summary>
/// Retorna a representação de uma planilha em memória que satisfaz o modelo passado como parâmetro
/// </summary>
/// <param name="classDiagramPath">caminho para o arquivo .classdiagram que contém o modelo</param>
/// <returns>represetação da planilha em memória</returns>
public XWorkbook createXWorkbook(string classDiagramPath)
{
ModelReader reader = new VscdReader(classDiagramPath);
CoreModelImpl model = (CoreModelImpl)reader.getModel();
OclTypesFactory.setEnvironment(model);
XWorkbook xWorkbook = new XWorkbook();
xWorkbook.setName(model.getName());
environment = model.getEnvironmentWithoutParents();
IEnumerable <CoreClassifier> modelClasses = getClasses(model);
foreach (CoreClassifier coreClassifier in modelClasses)
{
XWorksheet xWorksheet = new XWorksheet();
xWorksheet.setName(coreClassifier.getName());
xWorksheet.setWorkbook(xWorkbook);
updateWorkbook(xWorkbook, xWorksheet);
XDataTable xDataTable = new XDataTable();
xDataTable.setName(coreClassifier.getName());
xDataTable.setWorksheet(xWorksheet);
updateWorksheet(xWorksheet, xDataTable);
createFeatureColumns(coreClassifier, xDataTable, model);
createAssociationColumn(model, coreClassifier, xDataTable);
}
IEnumerable <CoreClassifier> enumerations = getEnumerations(model);
var iEnumerable = enumerations as IList <CoreClassifier> ?? enumerations.ToList();
if (enumerations != null && iEnumerable.Any())
{
foreach (CoreClassifier enumeration in iEnumerable)
{
XWorksheet xWorksheet = new XWorksheet();
xWorksheet.setName(enumeration.getName());
xWorksheet.setWorkbook(xWorkbook);
updateWorkbook(xWorkbook, xWorksheet);
XDataTable xDataTable = new XDataTable();
xDataTable.setName(enumeration.getName());
xDataTable.setWorksheet(xWorksheet);
updateWorksheet(xWorksheet, xDataTable);
XDataTableColumn xDataTableColumn = new XDataTableColumn();
xDataTableColumn.setName(enumeration.getName());
xDataTableColumn.setDataTable(xDataTable);
updateDataTable(xDataTable, xDataTableColumn);
XDataArray dataArray = new XDataArray();
var arraySymbol =
(from CoreAttributeImpl attribute in
enumeration.getClassifierFeatures().Where(f => f is CoreAttributeImpl)
select attribute.getName()).ToList();
dataArray.setArray(arraySymbol);
xDataTableColumn.setDataContent(dataArray);
}
}
return(xWorkbook);
}
