/// <summary>
/// Logs the entity.
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="structure">The structure of the entity.</param>
internal void LogEntity(Entity entity, EntityStructure structure)
{
StringBuilder stringBuilder = new StringBuilder("[Entity: " + entity.Name + "]\n");
foreach (var attribute in entity.AttributeValues)
{
if (structure.IsPrimaryKey(attribute.Key))
{
stringBuilder.Append(" - [PK] " + attribute.Key + " => " + attribute.Value + "\n");
}
else if (structure.IsForeignKey(attribute.Key))
{
stringBuilder.Append(" - " + attribute.Key + " => " + attribute.Value + " [FK references " + structure.ForeignKeys[attribute.Key].EntityName + "(" +
structure.ForeignKeys[attribute.Key].KeyName + ")" + "]\n");
}
else
{
stringBuilder.Append(" - " + attribute.Key + " => " + attribute.Value + "\n");
}
}
string info = stringBuilder.ToString();
try
{
StreamWriter file = new StreamWriter(ConfigurationManager.AppSettings["EntityManagerLogPath"], true);
file.WriteLine(info);
file.Close();
}
catch (Exception)
{
}
}
/// <summary>
/// Expands a referenced <paramref name="entityStructure"/> with the primary keys.
/// </summary>
/// <param name="entityStructure">An EntityStructure reference.</param>
internal void SetTablePrimaryKeys(ref EntityStructure entityStructure, string schema, string name)
{
StringBuilder builder = new StringBuilder("SELECT COL_NAME(ic.OBJECT_ID,ic.column_id) AS ColumnName ")
.Append("FROM sys.indexes AS i ")
.Append("INNER JOIN sys.index_columns AS ic ON i.OBJECT_ID = ic.OBJECT_ID AND i.index_id = ic.index_id ")
.Append("INNER JOIN sys.objects as obj ON ic.object_id = obj.object_id ")
.Append("WHERE i.is_primary_key = 1 AND SCHEMA_NAME(schema_id) = '")
.Append(schema)
.Append("' AND OBJECT_NAME(ic.OBJECT_ID) = '")
.Append(name)
.Append("'");
try
{
SqlDataReader dataReader = queryExecutor.ExecuteQuery(builder.ToString());
while (dataReader.Read())
{
entityStructure.PrimaryKeys.Add(dataReader[0].ToString());
}
dataReader.Close();
queryExecutor.CloseConnection();
}
catch (DbException)
{
throw;
}
}
public void LoadEntities(List <EntityWithKey> entities, string storagePath, string path, bool useLock = false)
{
try
{
entityStructures = serializedStorageClient.GetEntityStructures(path);
catalog = serializedStorageClient.GetCatalog(storagePath);
logger.StartNewLog();
// Restore the entities and its dependencies.
foreach (var entity in entities)
{
EntityStructure entityStructure = entityStructures.Find(entity.EntityName);
if (entityStructure == null)
{
throw new TdsLogicException("The given entity/table name (" + entity.EntityName + ") is not found.");
}
InnerLoadEntity(entity.EntityName, entity.PrimaryKeyValues, storagePath, useLock);
}
dbClient.ExecuteTransaction();
}
catch (Exception exception)
{
visitedEntities.Clear();
lockedEntities.Clear();
throw exception;
}
visitedEntities.Clear();
lockedEntities.Clear();
}
public IErrorsInfo CopyEntityStructure(IDataSource sourceds, IDataSource destds, string srcentity, string destentity, IProgress <PassedArgs> progress, CancellationToken token, bool CreateMissingEntity = true)
{
try
{
EntityStructure item = sourceds.GetEntityStructure(srcentity, true);
if (item != null)
{
if (destds.Category == DatasourceCategory.RDBMS)
{
IRDBSource rDB = (IRDBSource)destds;
rDB.DisableFKConstraints(item);
}
if (destds.CreateEntityAs(item))
{
DMEEditor.AddLogMessage("Success", $"Creating Entity {item.EntityName} on {destds.DatasourceName}", DateTime.Now, 0, null, Errors.Ok);
}
else
{
DMEEditor.AddLogMessage("Fail", $"Error : Could not Create Entity {item.EntityName} on {destds.DatasourceName}", DateTime.Now, 0, null, Errors.Failed);
}
if (destds.Category == DatasourceCategory.RDBMS)
{
IRDBSource rDB = (IRDBSource)destds;
rDB.EnableFKConstraints(item);
}
}
}
catch (Exception ex)
{
DMEEditor.AddLogMessage("Fail", $"Error Could not Create Entity {srcentity} on {destds.DatasourceName} ({ex.Message})", DateTime.Now, -1, "CopyDatabase", Errors.Failed);
}
return(DMEEditor.ErrorObject);
}
public async Task <object> GetEntityDataAsync(string EntityName, string filterstr)
{
var request = new HttpRequestMessage();
client = new HttpClient();
client.BaseAddress = new Uri(Dataconnection.ConnectionProp.Url);
EntityStructure ent = Dataconnection.ConnectionProp.Entities.Where(o => o.EntityName == EntityName).FirstOrDefault();
request.Method = HttpMethod.Get;
request.RequestUri = new Uri(Dataconnection.ConnectionProp.Url + filterstr);
foreach (WebApiHeader item in Dataconnection.ConnectionProp.Headers)
{
request.Headers.Add(item.headername, item.headervalue);
}
using (var response = await client.SendAsync(request).ConfigureAwait(false))
{
// response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
string retval = body;
if (!string.IsNullOrEmpty(ent.KeyToken) || !string.IsNullOrWhiteSpace(ent.KeyToken))
{
var data = JObject.Parse(body);
var location = data.SelectToken("category");
var categories = location.SelectToken(ent.KeyToken);
retval = categories.ToString();
}
var y = DMEEditor.ConfigEditor.JsonLoader.DeserializeObjectString <List <dynamic> >(retval);
return(y);
}
}
public Type GetEntityType(string EntityName)
{
EntityStructure x = GetEntityStructure(EntityName, false);
DMTypeBuilder.CreateNewObject(EntityName, EntityName, x.Fields);
return(DMTypeBuilder.myType);
}
public List <SyncEntity> GetCreateEntityScript(IDataSource ds, List <string> entities, IProgress <PassedArgs> progress, CancellationToken token)
{
List <SyncEntity> rt = new List <SyncEntity>();
try
{
foreach (string item in entities)
{
var t = Task.Run <EntityStructure>(() => { return(ds.GetEntityStructure(item, true)); });
t.Wait();
EntityStructure t1 = t.Result;
t1.Created = false;
}
if (ds.Entities.Count > 0)
{
var t = Task.Run <List <SyncEntity> >(() => { return(GetCreateEntityScript(ds, ds.Entities, progress, token)); });
t.Wait();
rt.AddRange(t.Result);
}
}
catch (System.Exception ex)
{
DMEEditor.AddLogMessage("Fail", $"Error in getting entities from Database ({ex.Message})", DateTime.Now, -1, "CopyDatabase", Errors.Failed);
}
return(rt);
}
/// <summary>
/// Expands a referenced <paramref name="entityStructure"/> with the attributes.
/// </summary>
/// <param name="entityStructure">An EntityStructure reference.</param>
internal void SetTableAttributes(ref EntityStructure entityStructure, string schema, string name)
{
StringBuilder builder = new StringBuilder("SELECT COLUMN_NAME,DATA_TYPE ")
.Append("FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = '")
.Append(schema)
.Append("' AND TABLE_NAME = '")
.Append(name)
.Append("'");
try
{
SqlDataReader dataReader = queryExecutor.ExecuteQuery(builder.ToString());
while (dataReader.Read())
{
entityStructure.Attributes.Add(dataReader[0].ToString(), dataReader[1].ToString());
}
dataReader.Close();
queryExecutor.CloseConnection();
}
catch (DbException)
{
throw;
}
}
public void SetConfig(IDMEEditor pDMEEditor, IDMLogger plogger, IUtil putil, string[] args, PassedArgs obj, IErrorsInfo per)
{
Passedarg = obj;
Logger = plogger;
util = putil;
ErrorObject = per;
DMEEditor = pDMEEditor;
vds = (DataViewDataSource)DMEEditor.GetDataSource(obj.DMView.DataViewDataSourceID);
Visutil = (IVisUtil)obj.Objects.Where(c => c.Name == "VISUTIL").FirstOrDefault().obj;
branch = (IBranch)obj.Objects.Where(c => c.Name == "Branch").FirstOrDefault().obj;
EntityStructure = (EntityStructure)obj.Objects.Where(c => c.Name == "EntityStructure").FirstOrDefault().obj;
if (obj.Objects.Where(c => c.Name == "ParentBranch").Any())
{
Parentbranch = (IBranch)obj.Objects.Where(c => c.Name == "ParentBranch").FirstOrDefault().obj;
ParentEntity = vds.GetEntityStructure(Parentbranch.BranchText, true);
}
if (obj.CurrentEntity != null)
{
EntityName = obj.CurrentEntity;
}
else
{
EntityName = "";
}
this.entitiesBindingNavigatorSaveItem.Click += EntitiesBindingNavigatorSaveItem_Click;
this.otherentitiesbindingSource.DataSource = vds.Entities.Where(o => o.Id > 0 && o.Id != EntityStructure.Id);
this.entitiesBindingSource.DataSource = EntityStructure;
this.fieldsBindingSource.DataSource = this.entitiesBindingSource;
//this.otherentityfieldsbindingSource.ResetBindings(true);
this.ParentEntitycomboBox.SelectedIndexChanged += ParentEntitycomboBox_SelectedIndexChanged;
}
public IMapping_rep CreateMapping(IMapping_rep x)
{
DMEEditor.ErrorObject.Flag = Errors.Ok;
try
{
IDataSource ds1 = DMEEditor.GetDataSource(x.Entity1DataSource);
IDataSource ds2 = DMEEditor.GetDataSource(x.Entity2DataSource);
if (ds1 == null || ds2 == null)
{
DMEEditor.ErrorObject.Flag = Errors.Failed;
DMEEditor.ErrorObject.Message = "one of the Datasources Dont Exist";
DMEEditor.Logger.WriteLog($"one of the Datasources Dont Exist");
}
else
{
EntityStructure dt1 = ds1.GetEntityStructure(x.EntityName1, false);
EntityStructure dt2 = ds2.GetEntityStructure(x.EntityName2, false);
x.Entity1Fields = dt1.Fields;
x.Entity2Fields = dt2.Fields;
DMEEditor.Logger.WriteLog($"Successful in Creating Mapping");
}
}
catch (System.Exception ex)
{
DMEEditor.ErrorObject.Flag = Errors.Failed;
DMEEditor.ErrorObject.Ex = ex;
x = null;
DMEEditor.Logger.WriteLog($"Error in Creating Mapping({ex.Message})");
}
return(x);
}
/// <summary>
/// Creates the insert query to insert the given entity.
/// </summary>
/// <param name="entity">An entity.</param>
/// <param name="entityStructure">The structure of the given entity.</param>
/// <returns>The SQL INSERT query string.</returns>
internal string CreateInsertQuery(Entity entity, EntityStructure entityStructure)
{
//INSERT INTO @Tablename VALUES (@Value1, @ValueN)//
StringBuilder builder = new StringBuilder("INSERT INTO ");
builder.Append(entity.Name)
.Append(" VALUES (");
string separator = "";
for (int i = 0; i < entity.AttributeValues.Count; i++)
{
string value = entity.AttributeValues.ElementAt(i).Value;
string type = entityStructure.Attributes[entity.AttributeValues.ElementAt(i).Key];
builder.Append(separator)
.Append(ConvertValue(value, type));
separator = ", ";
}
builder.Append(")");
return(builder.ToString());
}
/// <summary>
/// Creates the select query to retrieve the given entities.
/// </summary>
/// <param name="entityStructure">An entity structure.</param>
/// <param name="keyValues">The dictionary with the given keys and values.</param>
/// <returns>The SQL SELECT query string.</returns>
internal string CreateSelectQuery(EntityStructure entityStructure, Dictionary <string, string> keyValues)
{
//SELECT @Attribute1, @AttributeN//
StringBuilder builder = new StringBuilder("SELECT ");
string separator = "";
for (var i = 0; i < entityStructure.Attributes.Count; i++)
{
string attribute = entityStructure.Attributes.ElementAt(i).Key;
string type = entityStructure.Attributes.ElementAt(i).Value;
builder.Append(separator)
.Append(ConvertAttribute(attribute, type));
separator = ", ";
}
// FROM @TableName WHERE @KeyAttribute1 = @KeyValue1 AND @KeyAttributeN = @KeyValueN//
builder.Append(" FROM ")
.Append(entityStructure.Name)
.Append(" WHERE ");
separator = "";
for (var i = 0; i < keyValues.Count; i++)
{
string attribute = keyValues.ElementAt(i).Key;
string type = entityStructure.Attributes[keyValues.ElementAt(i).Key];
builder.Append(separator)
.Append('"').Append(attribute).Append('"').Append(" = ")
.Append(ConvertValue(keyValues.ElementAt(i).Value, type));
separator = " AND ";
}
return(builder.ToString());
}
private void FieldsBindingSource_AddingNew(object sender, AddingNewEventArgs e)
{
EntityStructure entityStructure = (EntityStructure)entitiesBindingSource.Current;
EntityField entityField = new EntityField();
entityField.EntityName = entityStructure.EntityName;
}
public EntityStructure GetEntityStructure(EntityStructure fnd, bool refresh = false)
{
if (Entities != null)
{
if (Entities.Count == 0)
{
if (Entities[0].Fields.Count == 0)
{
Getfields();
}
}
}
else
{
Entities = new List <EntityStructure>();
Getfields();
}
if (refresh)
{
Entities = new List <EntityStructure>();
Getfields();
}
if (Entities.Count == 1)
{
return(Entities[0]);
}
else
{
return(null);
}
}
public List <ChildRelation> GetChildTablesList(string tablename, string SchemaName, string Filterparamters)
{
EntityStructure dh = Entities[EntityListIndex(tablename)];
switch (dh.Viewtype)
{
case ViewType.Table:
return(GetDataSourceObject(tablename).GetChildTablesList(tablename, SchemaName, Filterparamters));
;
case ViewType.Query:
case ViewType.Code:
case ViewType.File:
case ViewType.Url:
default:
return(null);
}
}
public Type GetEntityType(string entityname)
{
EntityStructure dh = Entities[EntityListIndex(entityname)];
Type retval;
switch (dh.Viewtype)
{
case ViewType.Table:
retval = GetDataSourceObject(entityname).GetEntityType(entityname);
break;
case ViewType.Query:
case ViewType.Code:
case ViewType.File:
case ViewType.Url:
default:
DMTypeBuilder.CreateNewObject(entityname, entityname, dh.Fields);
retval = DMTypeBuilder.myType;
break;
}
return(retval);
}
//private void BlockColumnsDataGridView_CellContentClick(object sender, DataGridViewCellEventArgs e)
//{
// var senderGrid = (DataGridView)sender;
// if (senderGrid.Columns[e.ColumnIndex] is DataGridViewButtonColumn &&
// e.RowIndex >= 0)
// {
// //if ((object)column == (object)color)
// //{
// // colorDialog.Color = Color.Blue;
// // colorDialog.ShowDialog();
// //}
// }
//}
//private void BlockColumnsDataGridView_CellClick(object sender, DataGridViewCellEventArgs e)
//{
// // Ignore clicks that are not in our
// if (e.ColumnIndex == blockColumnsDataGridView.Columns["MyButtonColumn"].Index && e.RowIndex >= 0)
// {
// Console.WriteLine("Button on row {0} clicked", e.RowIndex);
// }
//}
private void BlocksBindingSource_CurrentChanged(object sender, EventArgs e)
{
ReportBlock x = (ReportBlock)blocksBindingSource.Current;
if (x.BlockColumns.Count() == 0)
{
if (!string.IsNullOrEmpty(this.viewIDComboBox.Text))
{
ds = (DataViewDataSource)DMEEditor.GetDataSource(this.viewIDComboBox.Text);
EntityStructure ent = ds.GetEntityStructure(this.entityIDComboBox.Text, true);
List <ReportBlockColumns> ls = new List <ReportBlockColumns>();
if (ent != null)
{
int i = 0;
foreach (EntityField item in ent.Fields)
{
ReportBlockColumns c = new ReportBlockColumns();
c.ColumnName = item.fieldname;
c.ColumnSeq = i;
c.DisplayName = item.fieldname;
c.Show = true;
i += 1;
ls.Add(c);
}
x.BlockColumns = ls;
}
}
}
}
private void EntitiesBindingSource_AddingNew(object sender, AddingNewEventArgs e)
{
EntityStructure entityStructure = new EntityStructure();
entityStructure.Drawn = false;
entityStructure.Editable = true;
e.NewObject = entityStructure;
}
public List <ChildRelation> GetChildTablesList(string tablename, string SchemaName, string Filterparamters)
{
EntityStructure ent = Entities.Where(p => p.EntityName.Equals(tablename, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
List <EntityStructure> ents = GetSeriesList(ent);
Entities.AddRange(ents);
return(null);
}
private void EntitiesBindingSource_AddingNew(object sender, AddingNewEventArgs e)
{
EntityStructure en = new EntityStructure();
DMDataView dv = (DMDataView)dataViewDataSourceBindingSource.Current;
en.ViewID = dv.ViewID;
e.NewObject = en;
}
private void Getfields()
{
ds = new DataSet();;
Entities = new List <EntityStructure>();
if (File.Exists(Path.Combine(Dataconnection.ConnectionProp.FilePath, Dataconnection.ConnectionProp.FileName)) == true)
{
try
{
string json = File.ReadAllText(Path.Combine(Dataconnection.ConnectionProp.FilePath, Dataconnection.ConnectionProp.FileName));
ds = DMEEditor.ConfigEditor.JsonLoader.DeserializeSingleObject <DataSet>(json);
int i = 0;
foreach (DataTable tb in ds.Tables)
{
EntityStructure entityData = new EntityStructure();
string sheetname;
sheetname = tb.TableName;
entityData.EntityName = sheetname;
entityData.DataSourceID = Dataconnection.ConnectionProp.ConnectionName;
// entityData.SchemaOrOwnerOrDatabase = Database;
List <EntityField> Fields = new List <EntityField>();
int y = 0;
foreach (DataColumn field in tb.Columns)
{
Console.WriteLine(" " + field.ColumnName + ": " + field.DataType);
EntityField f = new EntityField();
// f.tablename = sheetname;
f.fieldname = field.ColumnName;
f.fieldtype = field.DataType.ToString();
f.ValueRetrievedFromParent = false;
f.EntityName = sheetname;
f.FieldIndex = y;
Fields.Add(f);
y += 1;
}
i += 1;
entityData.Fields = new List <EntityField>();
entityData.Fields.AddRange(Fields);
Entities.Add(entityData);
}
}
catch (Exception)
{
}
}
else
{
DMEEditor.AddLogMessage("Error", "Json File Not Found " + Dataconnection.ConnectionProp.FileName, DateTime.Now, -1, "", Errors.Failed);
}
}
public void SaveEntity(Entity entity, EntityStructure entityStructure, string path)
{
if (!Directory.Exists(path + "\\Entities"))
{
Directory.CreateDirectory(path + "\\Entities");
}
entitiesToSave.Add(entity, BuildFileName(entity, entityStructure, path));
}
public List <object> ConvertTableToList(DataTable dt, EntityStructure ent, Type enttype)
{
List <object> retval = new List <object>();
if (dt.Rows.Count > 0)
{
foreach (DataRow dr in dt.Rows)
{
var ti = Activator.CreateInstance(enttype);
foreach (EntityField col in ent.Fields)
{
try
{
System.Reflection.PropertyInfo PropAInfo = ti.GetType().GetProperty(col.fieldname);
if (dr[col.fieldname] == System.DBNull.Value)
{
switch (col.fieldtype)
{
case "System.string":
break;
case "System.DateTime":
break;
}
PropAInfo.SetValue(ti, null, null);
}
else
{
// TrySetProperty<enttype>(ti, dr[col.fieldname], null);
PropAInfo.SetValue(ti, dr[col.fieldname], null);
}
}
catch (Exception ex)
{
}
// TrySetProperty<enttype>(ti, dr[col.fieldname], null);
}
retval.Add(ti);
}
}
else
{
var ti = Activator.CreateInstance(enttype);
foreach (EntityField col in ent.Fields)
{
System.Reflection.PropertyInfo PropAInfo = ti.GetType().GetProperty(col.fieldname);
PropAInfo.SetValue(ti, null, null);
}
retval.Add(ti);
}
return(retval);
}
private void ChangeDatasourceButton_Click(object sender, EventArgs e)
{
entitiesBindingSource.MoveFirst();
for (int i = 0; i <= entitiesBindingSource.Count; i++)
{
entity = (EntityStructure)entitiesBindingSource.Current;
entity.DataSourceID = this.NewDatasourcecomboBox1.Text;
entitiesBindingSource.MoveNext();
}
this.entitiesDataGridView.Refresh();
}
public EntityStructure GetEntityStructure(EntityStructure fnd, bool refresh = false)
{
if (Entities.Count > 0)
{
return(Entities[Entities.FindIndex(p => p.EntityName.Equals(fnd.EntityName, StringComparison.OrdinalIgnoreCase))]);
}
else
{
return(null);
}
}
private IDMDataView CreateViewUsingTable(EntityStructure EntitySource)
{
IDMDataView DataView = null;
IDataSource DataSource = null;
IDataSource EntityDataSource = null;
try
{
string viewname = null;
string fullname = null;
if (Visutil.controlEditor.InputBox("Create View", "Please Enter Name of View (Name Should not exist already in Views)", ref viewname) == System.Windows.Forms.DialogResult.OK)
{
if ((viewname != null) && DMEEditor.ConfigEditor.DataConnectionExist(viewname + ".json") == false)
{
fullname = Path.Combine(DMEEditor.ConfigEditor.Config.Folders.Where(x => x.FolderFilesType == FolderFileTypes.DataView).FirstOrDefault().FolderPath, viewname + ".json");
ConnectionProperties f = new ConnectionProperties
{
FileName = Path.GetFileName(fullname),
FilePath = Path.GetDirectoryName(fullname),
Ext = Path.GetExtension(fullname),
ConnectionName = Path.GetFileName(fullname)
};
f.Category = DatasourceCategory.VIEWS;
f.DriverVersion = "1";
f.DriverName = "DataViewReader";
DMEEditor.ConfigEditor.DataConnections.Add(f);
DataViewDataSource ds = (DataViewDataSource)DMEEditor.GetDataSource(f.ConnectionName);
EntityDataSource = DMEEditor.GetDataSource(EntitySource.DataSourceID);
if (EntitySource != null)
{
int x = ds.AddEntitytoDataView(EntityDataSource, EntitySource.EntityName, EntityDataSource.Dataconnection.ConnectionProp.SchemaName, null);
}
ds.WriteDataViewFile(fullname);
DataSource = DMEEditor.GetDataSource(f.ConnectionName);
DataView = ds.DataView;
DataView.EntityDataSourceID = EntityDataSource.DatasourceName;
}
DMEEditor.AddLogMessage("Success", "Added View", DateTime.Now, 0, null, Errors.Ok);
}
else
{
Visutil.controlEditor.MsgBox("DM Engine", "Please Try another name . DataSource Exist");
}
}
catch (Exception ex)
{
string mes = "Could not Added View ";
DMEEditor.AddLogMessage(ex.Message, mes, DateTime.Now, -1, mes, Errors.Failed);
};
return(DataView);
}
public int GenerateDataView(IDataSource conn, string tablename, string SchemaName, string Filterparamters)
{
//int maxcnt;
DMEEditor.ErrorObject.Flag = Errors.Ok;
List <ChildRelation> ds = conn.GetChildTablesList(tablename, SchemaName, Filterparamters);
//if (DataView.Entities.Count == 0)
//{
// EntityStructure viewheader = new EntityStructure() { Id = NextHearId(), EntityName = DataView.ViewName };
// viewheader.DataSourceID = conn.DatasourceName;
// viewheader.EntityName = DataView.ViewName.ToUpper();
// viewheader.ParentId = 0;
// viewheader.ViewID = DataView.ViewID;
// DataView.Entities.Add(viewheader);
//}
// maxcnt = DataView.Entities.Max(m => m.Id);
EntityStructure maintab = new EntityStructure()
{
Id = NextHearId(), EntityName = tablename
};
maintab.DataSourceID = conn.DatasourceName;
maintab.EntityName = tablename.ToUpper();
maintab.ViewID = DataView.ViewID;
maintab.DatasourceEntityName = tablename;
maintab.ParentId = 0;
DataView.Entities.Add(maintab);
EntitiesNames.Add(maintab.EntityName);
if (ds != null && ds.Count > 0)
{
// var tb = ds.Tables[0];
//-------------------------------
// Create Parent Record First
//-------------------------------
if (ds.Count > 0)
{
foreach (ChildRelation r in ds)
{
EntityStructure a;
a = SetupEntityInView(DataView, DataView.Entities, r.child_table, tablename, r.child_column, r.parent_column, maintab.Id, conn.DatasourceName);
}
}
}
return(maintab.Id);
}
private void CreateCategories(int categoryid, string categoryname, int entityid)
{
EntityStructure catent = new EntityStructure();
if (Entities.Count == 0)
{
catent.Id = 1;
}
else
{
catent.Id = Entities.Max(u => u.Id) + 1;
}
catent.ParentId = entityid;
catent.EntityName = categoryname;
catent.Viewtype = ViewType.Url;
catent.Category = "Category";
catent.DataSourceID = DatasourceName;
catent.CustomBuildQuery = $"/category/?api_key={Dataconnection.ConnectionProp.ApiKey}&category_id={categoryid}";
Entities.Add(catent);
var retval = GetCategoriesDataAsync("GetCategories", catent.CustomBuildQuery);
retval.Wait();
var data = JObject.Parse(retval.Result);
var categorytk = data.SelectToken("category");
Category categorys = JsonConvert.DeserializeObject <Category>(categorytk.ToString());
//if (categorys.childseries.Count() > 0)
//{
// foreach (Childsery childs in categorys.childseries)
// {
// EntityStructure serent = new EntityStructure();
// serent = new EntityStructure();
// serent.Id = Entities.Max(u => u.Id) + 1;
// serent.ParentId = catent.Id;
// serent.EntityName = childs.name;
// serent.Viewtype = ViewType.Url;
// serent.Category = "Series";
// serent.CustomBuildQuery = $"/series/?api_key={Dataconnection.ConnectionProp.ApiKey}&series_id={childs.series_id}";
// Entities.Add(serent);
// }
// ;
//}
if (categorys.childcategories.Count() > 0)
{
foreach (Childcategory ct in categorys.childcategories)
{
CreateChildCategories(ct, catent.Id);
}
}
}
public int AddEntitytoDataView(EntityStructure maintab)
{
DMEEditor.ErrorObject.Flag = Errors.Ok;
string tablename = maintab.DatasourceEntityName;
try
{
maintab.Id = NextHearId();
maintab.ViewID = 0;
if (maintab.ParentId == -1)
{
maintab.ParentId = 0;
}
//--- check entity already exist , if it does change Entity Name
if (CheckEntityExist(maintab.DatasourceEntityName))
{
int cnt = EntitiesNames.Where(p => p.Equals(maintab.DatasourceEntityName, StringComparison.OrdinalIgnoreCase)).Count() + 1;
maintab.EntityName = maintab.DatasourceEntityName + "_" + cnt;
}
DataView.Entities.Add(maintab);
EntitiesNames.Add(maintab.EntityName);
IDataSource entityds = DMEEditor.GetDataSource(maintab.DataSourceID);
if (entityds != null && entityds.Category == DatasourceCategory.RDBMS)
{
List <ChildRelation> ds = entityds.GetChildTablesList(maintab.DatasourceEntityName, entityds.Dataconnection.ConnectionProp.SchemaName, null);
if (ds != null && ds.Count > 0)
{
// var tb = ds.Tables[0];
//-------------------------------
// Create Parent Record First
//-------------------------------
if (ds.Count > 0)
{
foreach (ChildRelation r in ds)
{
EntityStructure a;
a = SetupEntityInView(DataView, DataView.Entities, r.child_table, maintab.DatasourceEntityName, r.child_column, r.parent_column, maintab.Id, entityds.DatasourceName);
}
}
}
}
return(maintab.Id);
}
catch (Exception)
{
return(-1);
}
}
public DataRow ConvertItemClassToDataRow(EntityStructure ent)
{
DataTable dt = new DataTable();
DataRow dr;
foreach (EntityField col in ent.Fields)
{
DataColumn co = dt.Columns.Add(col.fieldname);
co.DataType = Type.GetType(col.fieldtype);
}
dr = dt.NewRow();
return(dr);
}
