updating tests to run type def attribute tests. re-factoring code to …

…share more code across test classes.

api/Tests/CESMII.ProfileDesigner.Api.Tests/ControllerTests/ProfileTypeDefControllerIntegrationTest.cs

@@ -48,7 +48,7 @@ public class ProfileTypeDefControllerIntegrationTest : ProfileTypeDefControllerT
                                                      "'minValue':null,'maxValue':null,'engUnit':null,'compositionId':-999,'composition':{'id':-999,'name':'Test Comp Add','description':'','browseName':'','relatedProfileTypeDefinitionId':-999,'relatedName':'Test Comp Add'}," + 
                                                      "'interfaceId':-1,'interface':null,'description':'','displayName':'','typeDefinitionId':-888,'isArray':false,'isRequired':false,'enumValue':null}";
 
-    #region API constants
+        #region API constants
         private const string URL_INIT = "/api/profiletypedefinition/init";
         private const string URL_LIBRARY = "/api/profiletypedefinition/library";
         private const string URL_DELETE = "/api/profiletypedefinition/delete";
@@ -94,7 +94,7 @@ public async Task ExtendItem(int counter)
             var apiClient = base.ApiClient;
 
             //create parent profile and entity to extend
-            var itemExtend = await InsertMockProfileAndExtendEntity(_guidCommon);
+            var itemExtend = await InsertMockProfileAndTypeDefinition(TYPE_ID_DEFAULT, _guidCommon);
 
             // ACT
             //extend item
@@ -130,7 +130,7 @@ public async Task AddItem_GetItem(ProfileTypeDefinitionModel model)
 
             //treat inbound item as the new type def. Once we call extend, we need to apply some updates to it and save. 
             //create parent profile and entity to extend
-            var itemExtend = await InsertMockProfileAndExtendEntity(_guidCommon);
+            var itemExtend = await InsertMockProfileAndTypeDefinition(TYPE_ID_DEFAULT, _guidCommon);
             var resultExtend = await MapModelToExtendedItem(apiClient, _guidCommon, itemExtend, model);
             ////extend item
             //var resultExtend = await apiClient.ApiGetItemAsync<ProfileTypeDefinitionModel>(URL_EXTEND, 
@@ -189,7 +189,7 @@ public async Task DeleteItem(ProfileTypeDefinitionModel model)
             //add an item so that we can delete it
             //have to properly extend a base item, etc. before adding
             //then get the id of newly added item so we can call delete
-            var itemExtend = await InsertMockProfileAndExtendEntity(_guidCommon);
+            var itemExtend = await InsertMockProfileAndTypeDefinition(TYPE_ID_DEFAULT, _guidCommon);
             var resultExtend = await MapModelToExtendedItem(apiClient, _guidCommon, itemExtend, model);
             var resultAdd = await apiClient.ApiExecuteAsync<ResultMessageWithDataModel>(URL_ADD, resultExtend);
             var modelId = new IdIntModel() { ID = (int)resultAdd.Data };
@@ -217,7 +217,7 @@ public async Task NoDeleteParent(ProfileTypeDefinitionModel model)
             var apiClient = base.ApiClient;
             //add an item to a parent item and then try to delete parent.
             //we should get a message indicating can't delete parent due to dependency. Must delete child then you can delete parent.
-            var entityParent = await InsertMockProfileAndExtendEntity(_guidCommon);
+            var entityParent = await InsertMockProfileAndTypeDefinition(TYPE_ID_DEFAULT, _guidCommon);
             var modelChildNew = await MapModelToExtendedItem(apiClient, _guidCommon, entityParent, model);
             var resultChild = await apiClient.ApiExecuteAsync<ResultMessageWithDataModel>(URL_ADD, modelChildNew);
             var parentId = new IdIntModel() { ID = entityParent.ID.Value };
@@ -243,14 +243,15 @@ public async Task DeleteItemIntermediateObject(ProfileTypeDefinitionModel model)
             var apiClient = base.ApiClient;
 
             //insert base parent
-            var entityParent = await InsertMockProfileAndExtendEntity(_guidCommon);
+            var entityParent = await InsertMockProfileAndTypeDefinition(TYPE_ID_DEFAULT, _guidCommon);
             //extend base parent as item 1 - use this as composition for item 2
             var modelChild1New = await MapModelToExtendedItem(apiClient, _guidCommon, entityParent, model);
             var resultChild1Added = await apiClient.ApiExecuteAsync<ResultMessageWithDataModel>(URL_ADD, modelChild1New);
             var modelChild1Id = new IdIntModel() { ID = (int)resultChild1Added.Data };
             //extend base parent as item 2 - add composition pointing to item 1
             var modelChild2New = await MapModelToExtendedItem(apiClient, _guidCommon, entityParent, model);
             //add composition attribute pointing to child 1
+            //var attr = CreateAttributeComposition($"Attribute-Comp",  );
             var attr = JsonConvert.DeserializeObject<ProfileAttributeModel>(_attributeComposition);
             attr.CompositionId = modelChild1Id.ID;
             attr.Composition.ID = modelChild1Id.ID;
@@ -402,24 +403,24 @@ private async Task<List<ProfileTypeDefinition>> InsertMockEntitiesForSearchTests
 
                 //create a parent type definition - make parents null so it doesn't impact the 
                 //search calls
-                var parentClass = CreateEntity(0, profileMine.ID, null, _guidCommon, Guid.NewGuid(), user);
+                var parentClass = CreateEntity(0, profileMine.ID, null, TYPE_ID_DEFAULT, _guidCommon, Guid.NewGuid(), user);
                 parentClass.AuthorId = null;
                 parentClass.OwnerId = null;
                 parentClass.ExternalAuthor = _guidCommon.ToString();
                 await repo.AddAsync(parentClass);
-                var parentInterface = CreateEntity(0, profileMine.ID, null, _guidCommon, Guid.NewGuid(), user);
+                var parentInterface = CreateEntity(0, profileMine.ID, null, TYPE_ID_DEFAULT, _guidCommon, Guid.NewGuid(), user);
                 parentInterface.ProfileTypeId = (int)ProfileItemTypeEnum.Interface;
                 parentInterface.AuthorId = null;
                 parentInterface.OwnerId = null;
                 parentInterface.ExternalAuthor = _guidCommon.ToString();
                 await repo.AddAsync(parentInterface);
-                var parentEnum = CreateEntity(0, profileMine.ID, null, _guidCommon, Guid.NewGuid(), user);
+                var parentEnum = CreateEntity(0, profileMine.ID, null, TYPE_ID_DEFAULT, _guidCommon, Guid.NewGuid(), user);
                 parentEnum.ProfileTypeId = (int)ProfileItemTypeEnum.Enumeration;
                 parentEnum.AuthorId = null;
                 parentEnum.OwnerId = null;
                 parentEnum.ExternalAuthor = _guidCommon.ToString();
                 await repo.AddAsync(parentEnum);
-                var parentStructure = CreateEntity(0, profileMine.ID, null, _guidCommon, Guid.NewGuid(), user);
+                var parentStructure = CreateEntity(0, profileMine.ID, null, TYPE_ID_DEFAULT, _guidCommon, Guid.NewGuid(), user);
                 parentStructure.ProfileTypeId = (int)ProfileItemTypeEnum.Structure;
                 parentStructure.AuthorId = null;
                 parentStructure.OwnerId = null;
@@ -445,7 +446,7 @@ private async Task<List<ProfileTypeDefinition>> InsertMockEntitiesForSearchTests
                     //distribute the parent type def assignment
                     var p = i % 5 == 0 ? parentInterface : i % 4 == 0 ? parentClass : i % 3 == 0 ? parentStructure : parentEnum;
                     //set owner to 2/3 of the items
-                    var entity = CreateEntity(i, i % 3 == 0 ? profileCore.ID : profileMine.ID, p, _guidCommon, uuid, user);
+                    var entity = CreateEntity(i, i % 3 == 0 ? profileCore.ID : profileMine.ID, p, p.ProfileTypeId.Value, _guidCommon, uuid, user);
                     int? authorId = i % 3 == 0 ? null : user.ID;
                     entity.AuthorId = authorId;
                     entity.OwnerId = authorId;

api/Tests/CESMII.ProfileDesigner.Api.Tests/ControllerTests/ProfileTypeDefControllerTestBase.cs

@@ -7,7 +7,6 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Configuration;
 
-using Xunit;
 using Xunit.Abstractions;
 using Newtonsoft.Json;
 
@@ -26,14 +25,22 @@ public class ProfileTypeDefControllerTestBase : ControllerTestBase
         //for some tests, tie together a common guid so we can delete the created items at end of test. 
         protected Guid _guidCommon = Guid.NewGuid();
 
+        //get some lookup data that will be needed when we start adding addtribute tests
+        protected AppLookupModel _lookupData = null;
+        protected ProfileLookupModel _lookupRelated = null;
+
+        protected int _profileRootId;
+        protected int _compositionRootId;  //_baseObjectType id 
+        protected int _interfaceRootId;  //_baseInterfaceType id 
+        protected const string FN_GET_DESCENDANTS = "public.fn_profile_type_definition_get_descendants";
+
         #region API constants
-        //protected const string URL_INIT = "/api/profiletypedefinition/init";
         protected const string URL_EXTEND = "/api/profiletypedefinition/extend";
         protected const string URL_ADD = "/api/profiletypedefinition/add";
-        //protected const string URL_LIBRARY = "/api/profiletypedefinition/library";
         protected const string URL_GETBYID = "/api/profiletypedefinition/getbyid";
-        //protected const string URL_DELETE = "/api/profiletypedefinition/delete";
-        //protected const string URL_DELETE_MANY = "/api/profiletypedefinition/deletemany";
+
+        protected const string URL_LOOKUP_ALL = "/api/lookup/all";
+        protected const string URL_LOOKUP_RELATED = "/api/profiletypedefinition/lookup/profilerelated/extend";
         #endregion
 
         #region data naming constants
@@ -58,46 +65,100 @@ public ProfileTypeDefControllerTestBase(
             services.AddScoped<IRepository<Profile>, BaseRepo<Profile, ProfileDesignerPgContext>>();
             services.AddScoped<IRepository<ProfileTypeDefinition>, BaseRepo<ProfileTypeDefinition, ProfileDesignerPgContext>>();
             services.AddScoped<IRepository<ProfileTypeDefinitionAnalytic>, BaseRepo<ProfileTypeDefinitionAnalytic, ProfileDesignerPgContext>>();
+            services.AddScoped<IRepository<ProfileAttribute>, BaseRepo<ProfileAttribute, ProfileDesignerPgContext>>();
+            services.AddScoped<IRepository<LookupDataType>, BaseRepo<LookupDataType, ProfileDesignerPgContext>>();
+
+            services.AddScoped<IRepositoryStoredProcedure<ProfileTypeDefinitionSimple>, BaseRepoStoredProcedure<ProfileTypeDefinitionSimple, ProfileDesignerPgContext>>();
+
             //need to get user id of test user when we add profile
             services.AddScoped<IRepository<User>, BaseRepo<User, ProfileDesignerPgContext>>();
 
             _serviceProvider = services.BuildServiceProvider();
+
+            //note - base.ApiClient - this will force creation of test user if not yet added, this is needed downstream
+            //if we run this from a pristine db
+            PrepareMockData(base.ApiClient);
         }
 
 #pragma warning disable xUnit1026  // Stop warnings related to parameters not used in test cases. 
 
-        #region Helper Methods
-        /// <summary>
-        /// Create a mock parent item. Then set up a newly extended item with that parent item.
-        /// Finally, apply the model values to the newly extended item and return.
-        /// </summary>
-        /// <returns></returns>
-        protected async Task<ProfileTypeDefinitionModel> MapModelToExtendedItem(MyNamespace.Client apiClient, Guid guidCommon,
-            ProfileTypeDefinition itemExtend, ProfileTypeDefinitionModel model)
+        #region Insert Mock Data
+        protected void PrepareMockData(MyNamespace.Client apiClient)
         {
-            //extend item
-            var result = await apiClient.ApiGetItemAsync<ProfileTypeDefinitionModel>(URL_EXTEND,
-                new IdIntModel() { ID = itemExtend.ID.Value });
-            //map data to newly created extend
-            result.OpcNodeId = model.OpcNodeId;
-            result.Name = model.Name;
-            result.BrowseName = model.BrowseName;
-            result.SymbolicName = guidCommon.ToString();  //so we can delete this item once done
-            result.Description = model.Description;
-            result.Created = model.Created;
-            result.MetaTags = model.MetaTags;
-            result.Attributes = model.Attributes;
-            result.ProfileId = itemExtend.ProfileId;
-            result.Profile = new ProfileModel() { ID = itemExtend.ProfileId };
-            return result;
+            //to make this stateless (not dependent on the existence of other nodesets being present),
+            //create all of our own dependent data
+            InsertDependentMockData().Wait();
+
+            //get lookup data to be used when adding attributes
+            _lookupData = GetLookupData(apiClient, _guidCommon).Result;
+            //get related lookup data - variable types list, compositions, interfaces. Using mock data to keep this stateless.
+            _lookupRelated = GetRelatedData(_profileRootId);
+        }
+
+        protected async Task InsertDependentMockData()
+        {
+            //root type def and parent profile
+            var baseDataType = await InsertMockProfileAndTypeDefinition((int)ProfileItemTypeEnum.CustomDataType, _guidCommon, "_BaseDataType");
+            _profileRootId = baseDataType.ProfileId.Value;
+
+            using (var scope = _serviceProvider.CreateScope())
+            {
+                var repo = scope.ServiceProvider.GetService<IRepository<ProfileTypeDefinition>>();
+                var repoDataType = scope.ServiceProvider.GetService<IRepository<LookupDataType>>();
+                var repoUser = scope.ServiceProvider.GetService<IRepository<User>>();
+
+                var baseObjectType = await InsertMockTypeDefinition(repo, repoUser, _profileRootId, null, (int)ProfileItemTypeEnum.Class, _guidCommon, "_BaseObjectType");
+                _compositionRootId = baseObjectType.ID.Value;
+                var baseVariableType = await InsertMockTypeDefinition(repo, repoUser, _profileRootId, null, (int)ProfileItemTypeEnum.VariableType, _guidCommon, "_BaseVariableType");
+                var baseInterfaceType = await InsertMockTypeDefinition(repo, repoUser, _profileRootId, baseObjectType, (int)ProfileItemTypeEnum.Interface, _guidCommon, "_BaseInterfaceType");
+                _interfaceRootId = baseInterfaceType.ID.Value;
+                var baseEnumeration = await InsertMockTypeDefinition(repo, repoUser, _profileRootId, baseDataType, (int)ProfileItemTypeEnum.Enumeration, _guidCommon, "_Enumeration");
+
+                var baseDataVariableType = await InsertMockTypeDefinition(repo, repoUser, _profileRootId, baseVariableType, (int)ProfileItemTypeEnum.VariableType, _guidCommon, "_BaseDataVariableType");
+                //data types
+                var dt0 = await InsertMockTypeDefinition(repo, repoUser, _profileRootId, baseVariableType, (int)ProfileItemTypeEnum.VariableType, _guidCommon, "_Int");
+                await InsertMockDataType(repoDataType, dt0, _guidCommon);
+                var dt1 = await InsertMockTypeDefinition(repo, repoUser, _profileRootId, baseVariableType, (int)ProfileItemTypeEnum.VariableType, _guidCommon, "_DateTime");
+                await InsertMockDataType(repoDataType, dt1, _guidCommon);
+                var dt2 = await InsertMockTypeDefinition(repo, repoUser, _profileRootId, baseVariableType, (int)ProfileItemTypeEnum.VariableType, _guidCommon, "_Boolean");
+                await InsertMockDataType(repoDataType, dt2, _guidCommon);
+                var dt3 = await InsertMockTypeDefinition(repo, repoUser, _profileRootId, baseVariableType, (int)ProfileItemTypeEnum.VariableType, _guidCommon, "_Number");
+                await InsertMockDataType(repoDataType, dt3, _guidCommon);
+                var dt4 = await InsertMockTypeDefinition(repo, repoUser, _profileRootId, baseVariableType, (int)ProfileItemTypeEnum.VariableType, _guidCommon, "_String");
+                await InsertMockDataType(repoDataType, dt4, _guidCommon);
+                var dt5 = await InsertMockTypeDefinition(repo, repoUser, _profileRootId, baseVariableType, (int)ProfileItemTypeEnum.VariableType, _guidCommon, "_Double");
+                await InsertMockDataType(repoDataType, dt5, _guidCommon);
+                var dt6 = await InsertMockTypeDefinition(repo, repoUser, _profileRootId, baseVariableType, (int)ProfileItemTypeEnum.VariableType, _guidCommon, "_Float");
+                await InsertMockDataType(repoDataType, dt6, _guidCommon);
+
+                //variable types
+                await InsertMockTypeDefinition(repo, repoUser, _profileRootId, baseDataVariableType, (int)ProfileItemTypeEnum.VariableType, _guidCommon, "_FrameType");
+                await InsertMockTypeDefinition(repo, repoUser, _profileRootId, baseDataVariableType, (int)ProfileItemTypeEnum.VariableType, _guidCommon, "_ProgramDiagnosticType");
+                await InsertMockTypeDefinition(repo, repoUser, _profileRootId, baseDataVariableType, (int)ProfileItemTypeEnum.VariableType, _guidCommon, "_ReferenceDescriptionVariableType");
+                await InsertMockTypeDefinition(repo, repoUser, _profileRootId, baseDataVariableType, (int)ProfileItemTypeEnum.VariableType, _guidCommon, "_PubSubDiagnosticsCounterType");
+
+                //compositions - make them descendants of each other for more layers
+                var compCurrent = baseObjectType;
+                for (int i = 1; i <= 5; i++)
+                {
+                    compCurrent = await InsertMockTypeDefinition(repo, repoUser, _profileRootId, compCurrent, (int)ProfileItemTypeEnum.Class, _guidCommon, $"_BaseComposition_{i}");
+                }
+
+                //interfaces
+                await InsertMockTypeDefinition(repo, repoUser, _profileRootId, baseInterfaceType, (int)ProfileItemTypeEnum.Interface, _guidCommon, "_IVlanIdType");
+                await InsertMockTypeDefinition(repo, repoUser, _profileRootId, baseInterfaceType, (int)ProfileItemTypeEnum.Interface, _guidCommon, "_IOrderedObjectType");
+                //enumerations
+                await InsertMockTypeDefinition(repo, repoUser, _profileRootId, baseEnumeration, (int)ProfileItemTypeEnum.Enumeration, _guidCommon, "_ServerState");
+                await InsertMockTypeDefinition(repo, repoUser, _profileRootId, baseEnumeration, (int)ProfileItemTypeEnum.Enumeration, _guidCommon, "_ApplicationType");
+            }
         }
 
         /// <summary>
         /// Create a parent profile and an entity to extend from. 
         /// </summary>
         /// <param name="guidCommon"></param>
         /// <returns></returns>
-        protected async Task<ProfileTypeDefinition> InsertMockProfileAndExtendEntity(Guid guidCommon)
+        protected async Task<ProfileTypeDefinition> InsertMockProfileAndTypeDefinition(int typeId, Guid guidCommon, string name = null)
         {
             using (var scope = _serviceProvider.CreateScope())
             {
@@ -111,22 +172,253 @@ protected async Task<ProfileTypeDefinition> InsertMockProfileAndExtendEntity(Gui
                 await repoProfile.AddAsync(profile);
 
                 //create a parent type definition
-                var result = CreateEntity(0, profile.ID, null, guidCommon, Guid.NewGuid(), user);
+                var result = CreateEntity(0, profile.ID, null, typeId, guidCommon, Guid.NewGuid(), user);
+                if (!string.IsNullOrEmpty(name)) result.Name = name;
                 await repo.AddAsync(result);
 
                 //assign profile to type def in case caller needs it.
                 result.Profile = profile;
-                
+
                 return result;
             }
         }
 
+        protected async Task<ProfileTypeDefinition> InsertMockTypeDefinition(int profileId,
+            ProfileTypeDefinition parent, int typeId, Guid guidCommon, string name = null)
+        {
+            using (var scope = _serviceProvider.CreateScope())
+            {
+                var repo = scope.ServiceProvider.GetService<IRepository<ProfileTypeDefinition>>();
+                var repoUser = scope.ServiceProvider.GetService<IRepository<User>>();
+                return await InsertMockTypeDefinition(repo, repoUser, profileId, parent, typeId, guidCommon, name);
+            }
+        }
+
+        protected async Task<ProfileTypeDefinition> InsertMockTypeDefinition(
+            IRepository<ProfileTypeDefinition> repo,
+            IRepository<User> repoUser,
+            int profileId, ProfileTypeDefinition parent, int typeId, Guid guidCommon, string name = null)
+        {
+            var user = GetTestUser(repoUser);
+            //create a type definition
+            var result = CreateEntity(0, profileId, parent, typeId, guidCommon, Guid.NewGuid(), user);
+            if (!string.IsNullOrEmpty(name)) result.Name = name;
+            await repo.AddAsync(result);
+            return result;
+        }
+
+        protected async Task<LookupDataType> InsertMockDataType(
+            IRepository<LookupDataType> repo,
+            ProfileTypeDefinition typeDef, Guid guidCommon)
+        {
+            //create a data type, pointing to a type def
+            //sybmolic name includes guidCommon
+            var result = new LookupDataType() { Code = $"http://{guidCommon}/{typeDef.Name}", Name = typeDef.Name, CustomTypeId = typeDef.ID };
+            await repo.AddAsync(result);
+            return result;
+        }
+
+        /// <summary>
+        /// This is used to create a row directly into DB. Bypasses everything except baseRepo
+        /// </summary>
+        /// <param name="i"></param>
+        /// <param name="uuid"></param>
+        /// <param name="creator"></param>
+        /// <param name="cloudLibraryId"></param>
+        /// <returns></returns>
+        protected static ProfileTypeDefinition CreateEntity(int i, int? profileId, ProfileTypeDefinition parent, int typeId, Guid guidCommon, Guid uuid, User user)
+        {
+            var parentName = parent == null ? "TypeDef" : $"{parent.Name}::Extend";
+            var dt = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Utc);
+            var tags = new List<MetaTag>() {
+                new MetaTag() { Name = (i % 4 == 0 ? "abcd" : (i % 3 == 0) ? "efgh" : (i % 2 == 0) ? "ijkl" : "mnop") }
+            };
+            return new ProfileTypeDefinition()
+            {
+                OpcNodeId = uuid.ToString(),
+                Name = $"{parentName}-{i}",
+                ProfileId = profileId,
+                ParentId = parent?.ID,  //for some tests, we start with null parent and assign during test
+                BrowseName = $"browse-{i}-{guidCommon}-{uuid}",
+                SymbolicName = guidCommon.ToString(),
+                Description = (i % 3 == 0 ? "Unique description for 3" : (i % 2 == 0) ? "Unique description for 2" : "Common description"),
+                ProfileTypeId = parent == null ? typeId : parent?.ProfileTypeId,
+                IsAbstract = i % 9 == 0,
+                Created = dt,
+                Updated = dt,
+                AuthorId = user?.ID,
+                OwnerId = user?.ID,
+                CreatedById = user == null ? 0 : user.ID.Value,
+                UpdatedById = user == null ? 0 : user.ID.Value,
+                MetaTags = JsonConvert.SerializeObject(tags),
+                IsActive = true,
+            };
+        }
+
+        /// <summary>
+        /// This is used to create a row directly into DB. Bypasses everything except baseRepo
+        /// </summary>
+        protected static Profile CreateProfileEntity(Guid guidCommon, User user)
+        {
+            var dt = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Utc);
+            return new Profile()
+            {
+                Namespace = $"{PARENT_PROFILE_NAMESPACE}/{guidCommon}",
+                Title = TITLE_PATTERN,
+                Version = "1.0.0.0",
+                CategoryName = "TEST",
+                PublishDate = dt,
+                AuthorId = user?.ID,
+                OwnerId = user != null ? user.ID : null,
+                Keywords = new string[] { guidCommon.ToString() }
+            };
+        }
+
+        /// <summary>
+        /// Create a composition attribute
+        /// </summary>
+        protected static ProfileAttributeModel CreateAttributeComposition(
+            string name, string compositionName, Guid guidCommon,
+            ProfileLookupModel lookupRelated, AppLookupModel lookupData)
+        {
+            var dt = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Utc);
+            var comp = lookupRelated.Compositions.Find(x => x.Name.ToLower().Equals(compositionName.ToLower()));
+            var attrType = lookupData.AttributeTypes.Find(x => x.Name.ToLower().Equals("composition"));
+            //var dataType = _lookupData.DataTypes.Find(x => x.Name.ToLower().Equals("composition"));
+
+            return new ProfileAttributeModel()
+            {
+                CompositionId = comp.ID,
+                Composition = new ProfileTypeDefinitionRelatedModel()
+                {
+                    ID = comp.ID,
+                    SymbolicName = guidCommon.ToString(),
+                    RelatedProfileTypeDefinitionId = comp.ID,
+                    Name = comp.Name
+                },
+                AttributeType = attrType,
+                //matching happens on browse name - add unique portion to browse name
+                BrowseName = $"{Guid.NewGuid().ToString()}:::{guidCommon.ToString()}",
+                SymbolicName = guidCommon.ToString(),
+                //DataType = dataType,
+                //DataTypeId = dataType.ID,
+                Name = name
+            };
+        }
+
         protected static ProfileTypeDefinitionModel CreateItemModel(int i, int? profileId, ProfileTypeDefinition parent, Guid guidCommon, Guid uuid, string cloudLibraryId = null)
         {
-            var entity = CreateEntity(i, profileId, parent, guidCommon, uuid, null);
+            var entity = CreateEntity(i, profileId, parent, parent == null ? TYPE_ID_DEFAULT : parent.ProfileTypeId.Value, guidCommon, uuid, null);
             return MapToModel(entity);
         }
 
+        #endregion
+
+        #region Helper Methods
+        protected ProfileLookupModel GetRelatedData(int profileId)
+        {
+            using (var scope = _serviceProvider.CreateScope())
+            {
+                var repo = scope.ServiceProvider.GetService<IRepository<ProfileTypeDefinition>>();
+                var repoDataType = scope.ServiceProvider.GetService<IRepository<LookupDataTypeRanked>>();
+                var repoUser = scope.ServiceProvider.GetService<IRepository<User>>();
+                var repoRelated = scope.ServiceProvider
+                    .GetService<IRepositoryStoredProcedure<ProfileTypeDefinitionSimple>>();
+                var user = GetTestUser(repoUser);
+
+                var items = repo.FindByCondition(x => x.ProfileId.HasValue && x.ProfileId.Value.Equals(profileId));
+
+                var orderBys = new List<OrderBySimple>() { new OrderBySimple() { FieldName = "name" } };
+                var itemsComposition = repoRelated.ExecStoredFunction(FN_GET_DESCENDANTS, null, null, null, orderBys, 
+                    _compositionRootId, user.ID, false, false)
+                    .ToList();
+                //(fnName, null, skip, take, orderBys, parameters)
+                var itemsInterface = repoRelated.ExecStoredFunction(FN_GET_DESCENDANTS, null, null, null, orderBys, 
+                    _interfaceRootId, user.ID, false, false)
+                    .ToList();
+
+                return new ProfileLookupModel()
+                {
+                    VariableTypes = items.Where(x => x.ProfileTypeId.Equals((int)ProfileItemTypeEnum.VariableType))
+                                        .Select(x => new ProfileTypeDefinitionSimpleModel()
+                                        {
+                                            Name = x.Name,
+                                            //Type = (ProfileItemTypeEnum)x.ProfileTypeId.Value,
+                                            ProfileId = x.ProfileId.Value,
+                                            VariableDataTypeId = x.VariableDataTypeId.Value,
+                                            SymbolicName = x.SymbolicName,
+                                            ID = x.ID,
+                                            BrowseName = x.BrowseName,
+                                        }).ToList(),
+                    Compositions = itemsComposition
+                                        .Select(x => new ProfileTypeDefinitionSimpleModel()
+                                        {
+                                            Name = x.Name,
+                                            ProfileId = x.ProfileId,
+                                            VariableDataTypeId = x.VariableDataTypeId.HasValue ? x.VariableDataTypeId.Value : null,
+                                            ID = x.ID,
+                                            BrowseName = x.BrowseName,
+                                        }).ToList(),
+                    Interfaces = itemsInterface
+                                        .Select(x => new ProfileTypeDefinitionModel()
+                                        {
+                                            Name = x.Name,
+                                            ProfileId = x.ProfileId,
+                                            ID = x.ID,
+                                            BrowseName = x.BrowseName,
+                                        }).ToList()
+                };
+            }
+        }
+
+        protected async Task<AppLookupModel> GetLookupData(MyNamespace.Client apiClient, Guid guidCommon)
+        {
+            //get some static lookup data from db by calling api. get mock inserted data in a more direct manner.
+            var result = await apiClient.ApiGetItemGenericAsync<AppLookupModel>(URL_LOOKUP_ALL, method: "GET");
+
+            using (var scope = _serviceProvider.CreateScope())
+            {
+                //var repo = scope.ServiceProvider.GetService<IRepository<ProfileTypeDefinition>>();
+                var repoDataType = scope.ServiceProvider.GetService<IRepository<LookupDataType>>();
+
+                var itemDatatypes = repoDataType.FindByCondition(x => x.Code.Contains(guidCommon.ToString()));
+                result.DataTypes = itemDatatypes.Select(x => new LookupDataTypeRankedModel()
+                {
+                    Code = x.Code,
+                    BaseDataTypeId = x.CustomTypeId,
+                    CustomTypeId = x.CustomTypeId,
+                    Name = x.Name
+                }).ToList();
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Create a mock parent item. Then set up a newly extended item with that parent item.
+        /// Finally, apply the model values to the newly extended item and return.
+        /// </summary>
+        /// <returns></returns>
+        protected async Task<ProfileTypeDefinitionModel> MapModelToExtendedItem(MyNamespace.Client apiClient, Guid guidCommon,
+            ProfileTypeDefinition itemExtend, ProfileTypeDefinitionModel model)
+        {
+            //extend item
+            var result = await apiClient.ApiGetItemAsync<ProfileTypeDefinitionModel>(URL_EXTEND,
+                new IdIntModel() { ID = itemExtend.ID.Value });
+            //map data to newly created extend
+            result.OpcNodeId = model.OpcNodeId;
+            result.Name = model.Name;
+            result.BrowseName = model.BrowseName;
+            result.SymbolicName = guidCommon.ToString();  //so we can delete this item once done
+            result.Description = model.Description;
+            result.Created = model.Created;
+            result.MetaTags = model.MetaTags;
+            result.Attributes = model.Attributes;
+            result.ProfileId = itemExtend.ProfileId;
+            result.Profile = new ProfileModel() { ID = itemExtend.ProfileId };
+            return result;
+        }
+
+
         protected static ProfileTypeDefinitionModel MapToModel(ProfileTypeDefinition entity)
         {
             var tags = string.IsNullOrEmpty(entity.MetaTags) ? new List<string>() :
@@ -181,63 +473,7 @@ protected static ProfileTypeDefinitionSimpleModel MapToModelSimple(ProfileTypeDe
                 Author = new UserSimpleModel() {ID = entity.AuthorId } ,
                 IsAbstract = entity.IsAbstract,
                 MetaTags = string.IsNullOrEmpty(entity.MetaTags) ? new List<string>() :
-                    Newtonsoft.Json.JsonConvert.DeserializeObject<List<MetaTag>>(entity.MetaTags).Select(s => s.Name.Trim()).ToList(),
-            };
-        }
-
-        /// <summary>
-        /// This is used to create a row directly into DB. Bypasses everything except baseRepo
-        /// </summary>
-        /// <param name="i"></param>
-        /// <param name="uuid"></param>
-        /// <param name="creator"></param>
-        /// <param name="cloudLibraryId"></param>
-        /// <returns></returns>
-        protected static ProfileTypeDefinition CreateEntity(int i, int? profileId, ProfileTypeDefinition parent, Guid guidCommon, Guid uuid, User user)
-        {
-            var parentName = parent == null ? "TypeDef" : $"{parent.Name}::Extend";
-            var dt = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Utc);
-            var tags = new List<MetaTag>() { 
-                new MetaTag() { Name = (i % 4 == 0 ? "abcd" : (i % 3 == 0) ? "efgh" : (i % 2 == 0) ? "ijkl" : "mnop") }
-            };
-            return new ProfileTypeDefinition()
-            {
-                OpcNodeId = uuid.ToString(),
-                Name = $"{parentName}-{i}",
-                ProfileId = profileId,
-                ParentId = parent?.ID,  //for some tests, we start with null parent and assign during test
-                BrowseName = $"browse-{i}-{guidCommon}-{uuid}",
-                SymbolicName = guidCommon.ToString(),
-                Description = (i % 3 == 0 ? "Unique description for 3" : (i % 2 == 0) ? "Unique description for 2" : "Common description"),
-                ProfileTypeId = parent == null ? TYPE_ID_DEFAULT : parent?.ProfileTypeId,
-                IsAbstract = i % 9 == 0,
-                Created = dt,
-                Updated = dt,
-                AuthorId = user?.ID,
-                OwnerId = user?.ID,
-                CreatedById = user == null ? 0 : user.ID.Value,
-                UpdatedById = user == null ? 0 : user.ID.Value,
-                MetaTags = Newtonsoft.Json.JsonConvert.SerializeObject(tags),
-                IsActive = true,
-            };
-        }
-
-        /// <summary>
-        /// This is used to create a row directly into DB. Bypasses everything except baseRepo
-        /// </summary>
-        protected static Profile CreateProfileEntity(Guid guidCommon, User user)
-        {
-            var dt = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Utc);
-            return new Profile()
-            {
-                Namespace = $"{PARENT_PROFILE_NAMESPACE}/{guidCommon}",
-                Title = TITLE_PATTERN,
-                Version = "1.0.0.0",
-                CategoryName = "TEST",
-                PublishDate = dt,
-                AuthorId = user?.ID,
-                OwnerId = user != null ? user.ID : null,
-                Keywords = new string[] { guidCommon.ToString() }
+                    JsonConvert.DeserializeObject<List<MetaTag>>(entity.MetaTags).Select(s => s.Name.Trim()).ToList(),
             };
         }
 
@@ -253,10 +489,9 @@ protected virtual async Task CleanupEntities()
             {
                 //type defs
                 var repo = scope.ServiceProvider.GetService<IRepository<ProfileTypeDefinition>>();
-
-                //var repoUser = scope.ServiceProvider.GetService<IRepository<User>>();
-                //var user = GetTestUser(repoUser);
-                //var itemsAll = repo.FindByCondition(x => x.OwnerId.Equals(user.ID)).ToList();
+                var repoProfile = scope.ServiceProvider.GetService<IRepository<Profile>>();
+                var repoAttribute = scope.ServiceProvider.GetService<IRepository<ProfileAttribute>>();
+                var repoDataType = scope.ServiceProvider.GetService<IRepository<LookupDataType>>();
 
                 //order by to account for some fk delete issues, include child tables - analytics, attributes, compositions, interfaces
                 var items = repo.FindByCondition(x =>
@@ -270,11 +505,15 @@ protected virtual async Task CleanupEntities()
                     .ToList();
 
                 //parent profiles
-                var repoProfile = scope.ServiceProvider.GetService<IRepository<Profile>>();
                 var itemsProfile = repoProfile.FindByCondition(x =>
                     items.Select(y => y.ProfileId.Value).Contains(x.ID.Value))
                     .ToList();
 
+                //child attrs
+                var itemsAttribute = repoAttribute.FindByCondition(x =>
+                    items.Select(y => y.ID.Value).Contains(x.ProfileTypeDefinitionId.Value))
+                    .ToList();
+
                 //get intermediate items created server side that are related to items test created - intermediate objs
                 //assuming the item would be a child of the parent profile we will delete below. 
                 //prevent dups - only the items not collected above so that we don't try to delete something not there. 
@@ -287,42 +526,22 @@ protected virtual async Task CleanupEntities()
                     .Include(x => x.Attributes)
                     .ToList();
 
-                //works
-                //var itemsIntermediate = repo.FindByCondition(x =>
-                //    string.IsNullOrEmpty(x.SymbolicName) && ((ProfileItemTypeEnum)x.ProfileTypeId).Equals(ProfileItemTypeEnum.Object) 
-                //    && (x.InstanceParentId.HasValue && items.Select(y => y.ID.Value).Contains(x.InstanceParentId.Value))
-                //    )
-                //    .ToList();
-
-                //var itemsIntermediate = itemsIntermediate0.Where(x =>
-                //    items.Select(y => y.ID.Value).Contains(x.InstanceParentId.Value)
-                //    )
-                //    .ToList();
-                //var itemsIntermediate1 = itemsIntermediate0.Where(x =>
-                //    (x.ParentId.HasValue && items.Select(y => y.ID.Value).Contains(x.ParentId.Value)) ||
-                //    (x.InstanceParentId.HasValue && items.Select(y => y.ID.Value).Contains(x.InstanceParentId.Value))
-                //    )
-                //    .ToList();
-
-                /*
-                var itemsIntermediate = repo.FindByCondition(x =>
-                    string.IsNullOrEmpty(x.SymbolicName) && ((ProfileItemTypeEnum)x.ProfileTypeId).Equals(ProfileItemTypeEnum.Object) &&
-                    ((x.ParentId.HasValue && items.Select(y => y.ID.Value).Equals(x.ParentId.Value)) ||
-                    (x.InstanceParentId.HasValue && items.Select(y => y.ID.Value).Equals(x.InstanceParentId.Value))) 
-                    )
-                    .ToList();
-                */
-                //type def analytics
-                //var repoAnalytic = scope.ServiceProvider.GetService<IRepository<ProfileTypeDefinitionAnalytic>>();
-                //order to account for some fk delete issues
-                //var itemsAnalytic = repoAnalytic.FindByCondition(x =>
-                //    items.Select(y => y.ID.Value).Contains(x.ProfileTypeDefinitionId))
-                //    .ToList();
-                //foreach (var a in itemsAnalytic)
-                //{
-                    //await repoAnalytic.DeleteAsync(a);
-                //}
-                //await repoAnalytic.SaveChangesAsync();
+                var itemsDataType = repoDataType.FindByCondition(x => x.Code.Contains(_guidCommon.ToString())).ToList();
+
+                //order of operation matters - several dependencies and FK constraints
+                //attributes associated w/ type defs - do these first so we can remove FK in order to then delete data types
+                foreach (var item in itemsAttribute)
+                {
+                    await repoAttribute.DeleteAsync(item);
+                }
+                await repoAttribute.SaveChangesAsync();
+
+                //data types
+                foreach (var item in itemsDataType)
+                {
+                    await repoDataType.DeleteAsync(item);
+                }
+                await repoDataType.SaveChangesAsync();
 
                 //type defs
                 foreach (var item in items)
@@ -347,7 +566,6 @@ protected virtual async Task CleanupEntities()
         }
         #endregion
 
-
         /// <summary>
         /// do any post test cleanup here.
         /// </summary>

api/Tests/CESMII.ProfileDesigner.Api.Tests/ControllerTests/TypeDefControllerAttributeIntegrationTest.cs

@@ -3,49 +3,25 @@
 using System.Threading.Tasks;
 using System.Linq;
 
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Configuration;
-
 using Xunit;
 using Xunit.Abstractions;
-using Newtonsoft.Json;
 
 using CESMII.ProfileDesigner.Common.Enums;
 using CESMII.ProfileDesigner.DAL.Models;
-using CESMII.ProfileDesigner.Data.Repositories;
-using CESMII.ProfileDesigner.Data.Entities;
-using CESMII.ProfileDesigner.Data.Contexts;
 using CESMII.ProfileDesigner.Api.Shared.Models;
 
 namespace CESMII.ProfileDesigner.Api.Tests.Int
 {
     public class TypeDefControllerAttributeIntegrationTest : ProfileTypeDefControllerTestBase
     {
-        //get some lookup data that will be needed when we start adding addtribute tests
-        private AppLookupModel _lookupData = null;
-        private ProfileLookupModel _lookupRelated = null;
-
         #region API constants
-        private const string URL_LOOKUP_ALL = "/api/lookup/all";
-        private const string URL_LOOKUP_RELATED = "/api/profiletypedefinition/lookup/profilerelated/extend";
         #endregion
 
         public TypeDefControllerAttributeIntegrationTest(
-            CustomWebApplicationFactory<Api.Startup> factory, 
-            ITestOutputHelper output):
+            CustomWebApplicationFactory<Api.Startup> factory,
+            ITestOutputHelper output) :
             base(factory, output)
         {
-            //load lookup data that will be needed for attribute adds
-            //note there is a dependency that the DB contains this look up data prior to the test being run.
-            //some of the data is seeded by the create db script, some of the data is seeded by the import of the 
-            //2 root nodesets used everywhere - ua and ua/di
-
-            //get lookup data to be used when adding attributes
-            var apiClient = base.ApiClient;
-            _lookupData = apiClient.ApiGetItemGenericAsync<AppLookupModel>(URL_LOOKUP_ALL, method:"GET").Result;
-            //get related lookup data which depends on existence of type def
-            _lookupRelated = apiClient.ApiGetItemGenericAsync<ProfileLookupModel>(URL_LOOKUP_RELATED).Result;
-
         }
 
 #pragma warning disable xUnit1026  // Stop warnings related to parameters not used in test cases. 
@@ -56,31 +32,32 @@ public TypeDefControllerAttributeIntegrationTest(
         /// <param name="model"></param>
         /// <returns></returns>
         [Theory]
-        [InlineData(AttributeTypeIdEnum.DataVariable, "BaseDataVariableType", "Boolean", null, 5)]
-        [InlineData(AttributeTypeIdEnum.DataVariable, "TransitionVariableType", "Float", null, 4)]
-        [InlineData(AttributeTypeIdEnum.DataVariable, "AnalogItemType", "Double", null, 3)]
-        //[InlineData(AttributeTypeIdEnum.Property, null, "Int64", null, 5)]
-        //[InlineData(AttributeTypeIdEnum.Property, null, "Counter", null, 4)]
-        //[InlineData(AttributeTypeIdEnum.Property, null, "String", null, 3)]
-        //[InlineData(AttributeTypeIdEnum.StructureField, "BaseDataVariableType", "", null, 4)]
-        //[InlineData(AttributeTypeIdEnum.EnumField, "BaseDataVariableType", "", null, 3)]
+        [InlineData(AttributeTypeIdEnum.DataVariable, "_BaseDataVariableType", "_Boolean", 5)]
+        [InlineData(AttributeTypeIdEnum.DataVariable, "_BaseDataVariableType", "_Float", 4)]
+        [InlineData(AttributeTypeIdEnum.DataVariable, "_BaseDataVariableType", "_Double", 3)]
+        //[InlineData(AttributeTypeIdEnum.Property, null, "Int64", 5)]
+        //[InlineData(AttributeTypeIdEnum.Property, null, "Counter", 4)]
+        //[InlineData(AttributeTypeIdEnum.Property, null, "String", 3)]
+        //[InlineData(AttributeTypeIdEnum.StructureField, "BaseDataVariableType", "", 4)]
+        //[InlineData(AttributeTypeIdEnum.EnumField, "BaseDataVariableType", "", 3)]
         public async Task AddItem_AddAttributes(AttributeTypeIdEnum attrType, string variableTypeName
-            , string dataTypeName, string engUnitName, int numItems)
+            , string dataTypeName, int numItems)
         {
             // ARRANGE
             //get api client
             var apiClient = base.ApiClient;
 
             //create parent profile and entity to extend
-            var itemExtend = await InsertMockProfileAndExtendEntity(_guidCommon);
-            var model = CreateItemModel(1,itemExtend.ProfileId, itemExtend, _guidCommon, Guid.NewGuid());
+            var itemExtend = await InsertMockProfileAndTypeDefinition(TYPE_ID_DEFAULT, _guidCommon);
+            var model = CreateItemModel(1, itemExtend.ProfileId, itemExtend, _guidCommon, Guid.NewGuid());
             var resultExtend = await MapModelToExtendedItem(apiClient, _guidCommon, itemExtend, model);
 
             //add attributes
             resultExtend.ProfileAttributes = new List<ProfileAttributeModel>();
             for (int i = 1; i <= numItems; i++)
             {
-                resultExtend.ProfileAttributes.Add(CreateAttribute($"Attribute-{i}", attrType, variableTypeName, dataTypeName, engUnitName, _guidCommon));
+                var attr = CreateAttribute($"Attribute-{i}", attrType, variableTypeName, dataTypeName, _guidCommon);
+                resultExtend.ProfileAttributes.Add(attr);
             }
 
             // ACT
@@ -100,29 +77,35 @@ public async Task AddItem_AddAttributes(AttributeTypeIdEnum attrType, string var
         /// <summary>
         /// Extend from an item, then Add many different composition attributes and save. Confirm attributes added properly
         /// </summary>
+        /// <remarks>To pass in multiple strings in each test, separate with |</remarks>
         /// <param name="model"></param>
         /// <returns></returns>
         [Theory]
-        [InlineData("AlarmMetricsType", 1)]
-        [InlineData("AliasNameType", 1)]
-        [InlineData("PubSubConfigurationType", 1)]
-        [InlineData("ServerType", 1)]
-        public async Task AddItem_AddAttributeComposition(string compositionName, int numItems)
+        [InlineData(5)]
+        [InlineData(4)]
+        [InlineData(3)]
+        [InlineData(2)]
+        [InlineData(1)]
+        public async Task AddItem_AddAttributeComposition(int numItems)
         {
+            const string COMPOSITION_NAME_ROOT = "_BaseComposition_";
+
             // ARRANGE
             //get api client
             var apiClient = base.ApiClient;
 
             //create parent profile and entity to extend
-            var itemExtend = await InsertMockProfileAndExtendEntity(_guidCommon);
+            var itemExtend = await InsertMockProfileAndTypeDefinition(TYPE_ID_DEFAULT, _guidCommon);
             var model = CreateItemModel(1, itemExtend.ProfileId, itemExtend, _guidCommon, Guid.NewGuid());
             var resultExtend = await MapModelToExtendedItem(apiClient, _guidCommon, itemExtend, model);
 
             //add attributes
             resultExtend.ProfileAttributes = new List<ProfileAttributeModel>();
             for (int i = 1; i <= numItems; i++)
             {
-                resultExtend.ProfileAttributes.Add(CreateAttributeComposition($"Attribute-Comp-{i}", compositionName, _guidCommon));
+                var n = $"{COMPOSITION_NAME_ROOT}{i}";
+                resultExtend.ProfileAttributes.Add(CreateAttributeComposition($"Attribute-Comp-{i}", n, _guidCommon,
+                    _lookupRelated, _lookupData));
             }
 
             // ACT
@@ -143,14 +126,13 @@ public async Task AddItem_AddAttributeComposition(string compositionName, int nu
         /// Create an attribute
         /// </summary>
         private ProfileAttributeModel CreateAttribute(
-            string name, AttributeTypeIdEnum attrTypeId, string variableTypeName, string dataTypeName, 
-            string engUnitName, Guid guidCommon)
+            string name, AttributeTypeIdEnum attrTypeId, string variableTypeName, string dataTypeName, Guid guidCommon)
         {
             var dt = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Utc);
             var attrType = _lookupData.AttributeTypes.Find(x => x.ID.Value.Equals((int)attrTypeId));
             var dataType = _lookupData.DataTypes.Find(x => x.Name.ToLower().Equals(dataTypeName.ToLower()));
             var varType = string.IsNullOrEmpty(variableTypeName) ? null : _lookupRelated.VariableTypes.Find(x => x.Name.ToLower().Equals(variableTypeName.ToLower()));
-            var engUnit = string.IsNullOrEmpty(engUnitName) ? null : _lookupData.EngUnits.Find(x => x.DisplayName.ToLower().Equals(engUnitName.ToLower()));
+            //var engUnit = string.IsNullOrEmpty(engUnitName) ? null : _lookupData.EngUnits.Find(x => x.DisplayName.ToLower().Equals(engUnitName.ToLower()));
 
             return new ProfileAttributeModel()
             {
@@ -163,46 +145,14 @@ private ProfileAttributeModel CreateAttribute(
                 VariableTypeDefinition = string.IsNullOrEmpty(variableTypeName) ? null :
                         new ProfileTypeDefinitionModel() { ID = varType.ID, Name = varType.Name, BrowseName = varType.BrowseName },
                 VariableTypeDefinitionId = string.IsNullOrEmpty(variableTypeName) ? null : varType.ID,
-                EngUnit = engUnit,
+                //EngUnit = engUnit,
                 Name = name
             };
         }
 
-        /// <summary>
-        /// Create an attribute
-        /// </summary>
-        private ProfileAttributeModel CreateAttributeComposition(string name, string compositionName, Guid guidCommon)
-        {
-            var dt = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Utc);
-            var comp = _lookupRelated.Compositions.Find(x => x.Name.ToLower().Equals(compositionName.ToLower()));
-            var attrType = _lookupData.AttributeTypes.Find(x => x.Name.ToLower().Equals("composition"));
-            //var dataType = _lookupData.DataTypes.Find(x => x.Name.ToLower().Equals("composition"));
-
-            return new ProfileAttributeModel()
-            {
-                CompositionId = comp.ID,
-                Composition = new ProfileTypeDefinitionRelatedModel()
-                {
-                    ID = comp.ID,
-                    SymbolicName = _guidCommon.ToString(),
-                    RelatedProfileTypeDefinitionId = comp.ID,
-                    Name = comp.Name
-                },
-                AttributeType = attrType,
-                BrowseName = guidCommon.ToString(),
-                SymbolicName = guidCommon.ToString(),
-                //DataType = dataType,
-                //DataTypeId = dataType.ID,
-                Name = name
-            };
-        }
         #endregion
 
         //dispose happens in base class.
-        //public override void Dispose()
-        //{
-        //    CleanupEntities().Wait();
-        //}
 
     }
 }