public async Task <IHttpActionResult> Post([FromBody] ProjectMaster projectMaster)
{
if (!ModelState.IsValid)
{
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.InternalServerError, ModelState)));
}
using (_codeVortoService = new CodeVortoService())
{
var totalFiles =
Directory.GetFiles(projectMaster.PhysicalPath, "*.*", SearchOption.AllDirectories).Length;
projectMaster.TotalFiles = totalFiles;
projectMaster.UploadedDate = DateTime.Now;
projectMaster.UploadedTime = DateTime.Now;
projectMaster.SolutionId = projectMaster.LanguageId;
var project = await _codeVortoService.ProjectMasterRepository
.AddNewItem(projectMaster).ConfigureAwait(false);
if (project == null)
{
return(BadRequest("Project name already exist"));
}
return(Ok(project));
}
}
public async void Post([FromBody] FileTypeReference fileTypeReference)
{
using (_codeVortoService = new CodeVortoService())
{
await _codeVortoService.FileTypeReferenceRepository.AddNewItem(fileTypeReference);
}
}
public async Task <IHttpActionResult> Get()
{
_codeVortoService = new CodeVortoService();
var usersList = await _codeVortoService.UserMasterRepository.GetAllItems();
return(Ok(usersList));
}
public IHttpActionResult Get()
{
using (_codeVortoService = new CodeVortoService())
{
var allActionWorkflows = _codeVortoService.ActionWorkflowsRepository.GetAllItems();
return(Ok(allActionWorkflows));
}
}
public IHttpActionResult Get(int projectId)
{
using (_codeVortoService = new CodeVortoService())
{
var projectMaster = _codeVortoService.ProjectMasterRepository.GetItem(projectId);
return(Ok(projectMaster));
}
}
public async Task <IHttpActionResult> Get()
{
using (_codeVortoService = new CodeVortoService())
{
var data = await _codeVortoService.FileTypeReferenceRepository.GetAllItems();
return(Ok(data));
}
}
public async Task <IHttpActionResult> Get()
{
using (_codeVortoService = new CodeVortoService())
{
var fileTypeExtensionList = await _codeVortoService.FileTypeExtensionRepository.GetAllItems();
return(Ok(fileTypeExtensionList));
}
}
public async Task <ProjectMaster> GetUnProcessedProject()
{
using (_codeVortoService = new CodeVortoService())
{
var projectMaster = await _codeVortoService.ProjectMasterRepository.GetItem <ProjectMaster>(x => x.Processed == 0);
// projectMaster = projectMaster ?? new ProjectMaster();
return(projectMaster);
}
}
public async Task <IHttpActionResult> GetApplicationLocChart(int projectId)
// To Get all the application LOC Chart
{
using (_codeVortoService = new CodeVortoService())
{
var objChart = new Chart {
Charts = new List <ChartItem>()
};
//var projectId = 0;
try
{
var generalRepository =
new GeneralRepository <ChartDashboardCount>(new AppDbContext());
object[] parameters =
{
new MySqlParameter("prjId", MySqlDbType.Int32)
{
Value = projectId
}
};
var chartData = await generalRepository
.ExecuteStoreProcedure <ChartDashboardCountNew>("SpChartLOCDashboard", parameters);
if ((chartData.Count > 0) && (chartData.Count > 0))
{
#region Added Chart data
if (chartData.Count > 0)
{
for (var i = 0; i < chartData.Count; i++)
{
if (Convert.ToInt32(chartData[i].Count) != 0)
{
objChart.Charts.Add(new ChartItem
{
label = chartData[i].Extension.Replace(".", ""),
data = Convert.ToInt32(chartData[i].Count),
color = "#8669CC"
});
}
}
}
#endregion
}
}
catch (Exception exception)
{
return(InternalServerError(exception));
}
return(Ok(objChart));
}
}
public IHttpActionResult GetAll()
{
using (_codeVortoService = new CodeVortoService())
{
Expression <Func <StatementReferenceMaster, bool> > expression = master => master.BaseCommandId == 10;
//Predicate<StatementReferenceMaster> predicate = p => p.BaseCommandId == 10;
var allData = _codeVortoService.StatementReferenceMasterRepository
.GetAllListItems(expression);
return(Ok(allData));
}
}
public async Task <IHttpActionResult> UpdateWorkflowDesc(int workflowId, string workflowDesc)
{
using (_codeVortoService = new CodeVortoService())
{
var item = _codeVortoService.ActionWorkflowsRepository
.GetItem(workflowId);
item.WorkflowBusinessDescription = workflowDesc;
var data = await _codeVortoService.ActionWorkflowsRepository
.UpdateItem(item);
return(Ok(data));
}
}
public async Task <IHttpActionResult> SearchProjects(string fromDate, string toDate)
{
using (_codeVortoService = new CodeVortoService())
{
var frmDate = Convert.ToDateTime(fromDate).ToShortDateString();
var tDate = Convert.ToDateTime(toDate).ToShortDateString();
var sqlQuery = "Select * from ProjectMaster where UploadedDate BETWEEN '" + frmDate + "' AND '" +
tDate + "'; ";
var projectsList = await _codeVortoService.ProjectMasterRepository
.GetDataFromSqlQuery <ProjectMaster>(sqlQuery);
return(Ok(projectsList));
}
}
public async Task <IHttpActionResult> GetAllStartingPoints(int projectId, int stmtId)
{
using (_codeVortoService = new CodeVortoService())
{
var workflowRef = await _codeVortoService.ActionWorkflowsRepository
.GetDataFromSqlQuery <ActionWorkflows>(
" SELECT * FROM actionworkflows where ProjectId = " + projectId +
" and MethodStatementId != 0 AND (EndPointOrService = 'Service' OR EndPointOrService = 'Batch'); ");
var projectMaster = _codeVortoService.ProjectMasterRepository.GetItem(projectId);
workflowRef[0].ProjectMaster = projectMaster;
var lstWorkflowRef = workflowRef.ToList();
return(Ok(lstWorkflowRef));
}
}
public async Task <IHttpActionResult> Post([FromBody] List <FileTypeExtensionReference> lstFileTypeExtensionReferences)
{
if (!ModelState.IsValid)
{
return(BadRequest("Request is invalid"));
}
using (_codeVortoService = new CodeVortoService())
{
foreach (var fileType in lstFileTypeExtensionReferences)
{
await _codeVortoService.FileTypeExtensionRepository.AddNewItem(fileType);
}
return(Ok(lstFileTypeExtensionReferences));
}
}
public async Task <IHttpActionResult> ExecuteProcessActionsOneByOne(int projectId)
{
using (_codeVortoService = new CodeVortoService())
{
var stringBuilder = new StringBuilder();
try
{
var projectMaster = _codeVortoService.ProjectMasterRepository.GetItem(projectId);
if (projectMaster == null)
{
return(BadRequest("Details provided are not correct."));
}
int solutionId = projectMaster.SolutionId ?? 0;
DateTime startDate = DateTime.Now;
string dashLine =
"=================================================================================\n";
string startStatus = "Started executing Method: StartProcessUbProject\nDate: " +
DateTime.Now.ToString("g") + "\nTime: " +
DateTime.Now.ToString("HH:m:s tt zzz");
Console.WriteLine(dashLine);
Console.WriteLine(startStatus);
stringBuilder.AppendLine(dashLine).AppendLine(startStatus);
await StartProcessUbProject(projectMaster.ProjectId).ConfigureAwait(false); // Done
string endStatus = "Completed executing Method: StartProcessUbProject\nDate: " +
DateTime.Now.ToString("g") + "\nTime: " +
DateTime.Now.ToString("HH:m:s tt zzz");
Console.WriteLine(endStatus);
Console.WriteLine(dashLine);
stringBuilder.AppendLine(dashLine).AppendLine(endStatus);
//
var projectJson = JsonConvert.SerializeObject(projectMaster, Formatting.Indented);
return(Ok("Project processed successfully with all methods one by one. Project Details: " + projectJson));
}
catch (Exception exception)
{
Console.WriteLine(exception.InnerException);
return(InternalServerError(exception));
}
}
}
public async Task <IHttpActionResult> UpdateProjectStatus(int projectId)
{
using (_codeVortoService = new CodeVortoService())
{
var projectMaster = _codeVortoService.ProjectMasterRepository.GetItem(projectId);
if (projectMaster == null)
{
return(BadRequest("Project not found"));
}
projectMaster.Processed = 1;
projectMaster.ProcessedDate = DateTime.Now;
projectMaster.ProcessedTime = DateTime.Now;
await _codeVortoService.ProjectMasterRepository.UpdateItem(projectMaster);
return(Ok(projectMaster));
}
}
public async Task <IHttpActionResult> Get(int bCommandId1, int bCommandId2)
{
Predicate <StatementReferenceMaster> predicate = p =>
p.BaseCommandId == bCommandId1 ||
p.BaseCommandId == bCommandId2;
using (_codeVortoService = new CodeVortoService())
{
var statementReference =
await _codeVortoService.StatementReferenceMasterRepository.GetAllItems(predicate);
NameValueData lstNameValueData = new NameValueData();
List <NameValue> lstAllClasses = new List <NameValue>();
List <NameValue> lstAllMethods = new List <NameValue>();
var statementReferenceMasters = statementReference as StatementReferenceMaster[] ??
statementReference.ToArray();
var allClasses = (from stmt in statementReferenceMasters
where stmt.BaseCommandId == bCommandId2
select stmt).ToList();
var allMethods = (from stmt in statementReferenceMasters
where stmt.BaseCommandId == bCommandId1
select stmt).ToList();
lstNameValueData.Classes = new List <NameValue>();
lstAllClasses.AddRange(
allClasses.Select(master =>
new NameValue
{
Value = master.StatementId,
Name = master.ClassNameDeclared
}));
lstNameValueData.Classes.AddRange(lstAllClasses);
lstNameValueData.Methods = new List <NameValue>();
lstAllMethods.AddRange(
allMethods.Select(master =>
new NameValue
{
Value = master.StatementId,
Name = master.MethodName
}));
lstNameValueData.Methods.AddRange(lstAllMethods);
return(Ok(lstNameValueData));
}
}
public async Task <IHttpActionResult> Get()
{
using (_codeVortoService = new CodeVortoService())
{
var projectList = await _codeVortoService.ProjectMasterRepository.GetAllItems();
var projectMasters = projectList as IList <ProjectMaster> ?? projectList.ToList();
foreach (var project in projectMasters)
{
if (project.UploadedTime != null)
{
project.UploadedTm = project.UploadedTime.Value.ToString("HH:mm tt");
}
if (project.ProcessedTime != null)
{
project.ProcessedTm = project.ProcessedTime.Value.ToString("HH:mm tt");
}
}
return(Ok(projectMasters));
}
}
public async Task <IHttpActionResult> UserLogin([FromBody] UserMaster user)
{
if (!ModelState.IsValid)
{
return(BadRequest("Username or password is invalid. Try again"));
}
try
{
using (_codeVortoService = new CodeVortoService())
{
string password = user.Password;
string encrptedPass = ClsUserMaster.EncryptPassword(password);
/*
* string decrptedPass = ClsUserMaster.DecryptPassword(encrptedPass);
* string d = decrptedPass;
* string e = encrptedPass;
*/
Expression <Func <UserMaster, bool> > expression = e => e.UserName == user.UserName &&
e.Password == encrptedPass;
var userMaster = await _codeVortoService.UserMasterRepository
.GetItem <UserMaster>(expression, 1);
if (userMaster == null)
{
return(BadRequest("User not found"));
}
var userDetails = userMaster.UserDetails.First();
return(Ok(userDetails));
}
}
catch (Exception exception)
{
return(InternalServerError(exception));
}
}
public FileTypeReferenceController(ICodeVortoService codeVortoService)
{
_codeVortoService = codeVortoService;
}
public async Task <IHttpActionResult> StartProcessIncludesFile(int projectId) // projectId =2
{
using (_codeVortoService = new CodeVortoService())
{
var stringBuilder = new StringBuilder();
var fileMaster = await _codeVortoService.FileMasterRepository
.GetAllListItems(
x => x.ProjectId == projectId && x.FileTypeExtensionId == 12 && x.Processed == 0);
foreach (var fMaster in fileMaster)
{
var lstFileLines = File.ReadAllLines(fMaster.FilePath).ToList();
if (lstFileLines.Count <= 0)
{
return(Ok("No contents in file: " + fMaster.FilePath));
}
await ParseCallAndIncludesFilesUniverse(fMaster, 5, fileMaster);
#region Update field for basecommandId = 45
stringBuilder.AppendLine(
"========================================================================================");
stringBuilder.AppendLine("Started update field for basecommandId = 45 for Project: " + projectId + "");
var sqlQuery = " SELECT * FROM UniverseBasicDataDictionary WHERE ProjectId=" + projectId + " GROUP BY FileName;";
var universeBasicDataDicyionary =
await _codeVortoService.DataDictionaryRepository.GetDataFromSqlQuery <DataDictionary>(sqlQuery);
foreach (var dataDictionary in universeBasicDataDicyionary)
{
string tableName = dataDictionary.Description;
string fileName = dataDictionary.FileName;
string sqlQry = "SELECT * from statementreferencemaster WHERE fileId=" + fMaster.FileId +
" AND OriginalStatement like '%" + fileName + "%';";
var statementRefMaster =
await
_codeVortoService.StatementReferenceMasterRepository
.GetDataFromSqlQuery <StatementReferenceMaster>(sqlQry).ConfigureAwait(false);
foreach (var statementRef in statementRefMaster)
{
if (fileName != null)
{
var newStatement = Regex.Replace(!string.IsNullOrEmpty(statementRef.AlternateName) ? statementRef.AlternateName : statementRef.OriginalStatement, fileName, tableName, RegexOptions.IgnoreCase);
if (statementRef.BaseCommandId != 0)
{
statementRef.AlternateName = newStatement;
statementRef.BusinessName = newStatement;
statementRef.ResolvedStatement = newStatement;
}
else
{
statementRef.BaseCommandId = 45;
statementRef.AlternateName = newStatement;
statementRef.BusinessName = newStatement;
statementRef.ResolvedStatement = newStatement;
}
}
await _codeVortoService.StatementReferenceMasterRepository.UpdateItem(statementRef);
}
}
stringBuilder.AppendLine(
"========================================================================================");
stringBuilder.AppendLine("Ended update field for basecommandId = 45 for ProjectId: " + projectId + "");
#endregion
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public ProcessIncludesController(ICodeVortoService codeVortoService)
{
}
public async Task <IHttpActionResult> ParseCallAndIncludesFilesUniverse(FileMaster icdFile, int languageId, List <FileMaster> copyOfFileMaster)
{
var stringBuilder = new StringBuilder();
int commanClassProjId = 9;
using (_codeVortoService = new CodeVortoService())
{
#region Load Project and Base Command Reference Details...
var baseCommandReferenceRepository = new BaseCommandReferenceRepository(new AppDbContext());
var baseCommandReference = await baseCommandReferenceRepository.GetAllItems()
.ContinueWith(t =>
{
var result = t.Result;
return(result.ToList());
});
var lineCommentedIndicators =
baseCommandReference.Find(s => s.BaseCommand == "Line Comment")
.PrimaryLanguageReference.ToList().FindAll(p => p.LanguageId == languageId);
var ifConditionStart = baseCommandReference.Find(s => s.BaseCommand == "IF Start")
.PrimaryLanguageReference.ToList().FindAll(p => p.LanguageId == languageId);
var ifConditionEnd = baseCommandReference.Find(s => s.BaseCommand == "IF End")
.PrimaryLanguageReference.ToList().FindAll(p => p.LanguageId == languageId);
var callExternalIndicationStart = baseCommandReference.Find(s => s.BaseCommand == "Call External")
.PrimaryLanguageReference.ToList().FindAll(p => p.LanguageId == languageId);
var methodIndicationEnd = baseCommandReference.Find(s => s.BaseCommand == "Method End")
.PrimaryLanguageReference.ToList().FindAll(p => p.LanguageId == languageId);
var callInternalIndicationStart = baseCommandReference.Find(s => s.BaseCommand == "Call Internal")
.PrimaryLanguageReference.ToList().FindAll(p => p.LanguageId == languageId);
var loopIndicatorStart = baseCommandReference.Find(s => s.BaseCommand == "Loop Start")
.PrimaryLanguageReference.ToList().FindAll(p => p.LanguageId == languageId);
var loopIndicatorEnd = baseCommandReference.Find(s => s.BaseCommand == "Loop End")
.PrimaryLanguageReference.ToList().FindAll(p => p.LanguageId == languageId);
var universeBasicV1 = new UniverseBasicVersion1();
var callClassIndicatorStart = baseCommandReference.Find(s => s.BaseCommand == "Class Start")
.PrimaryLanguageReference.ToList().FindAll(p => p.LanguageId == languageId);
var callClassIndicatorEnd = baseCommandReference.Find(s => s.BaseCommand == "Class End")
.PrimaryLanguageReference.ToList().FindAll(p => p.LanguageId == languageId);
var methodIndicationStart = baseCommandReference.Find(s => s.BaseCommand == "Method Start")
.PrimaryLanguageReference.ToList().FindAll(p => p.LanguageId == languageId);
var methodEnd = methodIndicationEnd.Find(x => true);
var classStart = callClassIndicatorStart.Find(x => true);
var classEnd = callClassIndicatorEnd.Find(x => true);
var methodStart = methodIndicationStart.Find(x => true);
#endregion
var programFileLines = File.ReadAllLines(icdFile.FilePath).ToList();
int projectId = icdFile.ProjectId;
programFileLines.RemoveAll(s => s.Length <= 0);
programFileLines = programFileLines.Select(s => s.Trim()).ToList();
programFileLines = programFileLines.AdjustMatReadLockedLikeStatements();
//
var copyOfFileLines = programFileLines.ToList();
programFileLines = programFileLines.Where(s => !s.StartsWith("*") &&
!s.StartsWith("!!") && !s.StartsWith(";*") &&
!s.StartsWith("; *")).ToList();
#region Correct all method blocks and statements...
// Program file processing started...
var programLineList = new List <string>();
stringBuilder.AppendLine("========================================================================================");
stringBuilder.AppendLine("Started collecting all GOSUB: GetAllGoSub for project:" + projectId);
var lstAllGoSubs = programFileLines.GetAllGoSub("GOSUB");
Dictionary <string, List <string> > methodBlockDictionary;
stringBuilder.AppendLine("========================================================================================");
stringBuilder.AppendLine("Started collecting all certainpointInclude: GetListFromCertainPointInclude for project: " + projectId);
methodBlockDictionary = universeBasicV1.GetListFromCertainPointInclude(copyOfFileLines,
lstAllGoSubs);
var startedBlock = false;
for (var length = 0; length < programFileLines.Count; length++)
{
var currentLine = programFileLines[length];
if (lstAllGoSubs.Any(l => currentLine.StartsWith(l)))
{
startedBlock = true;
var firstOrDefault = currentLine.Split('*').FirstOrDefault();
if (firstOrDefault != null)
{
currentLine = firstOrDefault.Trim();
}
stringBuilder.AppendLine("========================================================================================");
stringBuilder.AppendLine("Started collecting all methodblocks: PickUpAllMethodBlocks for project:" + projectId);
var methodBlockOriginal = universeBasicV1.PickUpAllMethodBlocks(copyOfFileLines,
programFileLines[length], lstAllGoSubs, "RETURN", "STOP");
var methodBlock = methodBlockDictionary.FirstOrDefault(s => s.Key == currentLine);
programLineList.AddRange(methodBlock.Value);
length = length + methodBlockOriginal.Count - 1;
continue;
}
if (startedBlock)
{
continue;
}
programLineList.Add(currentLine);
}
#endregion
var statmentRefStart = universeBasicV1.PrepareStatementReferenceMasterStart(icdFile, 42);
await _codeVortoService.StatementReferenceMasterRepository.BulkInsert(statmentRefStart);
#region Insert into StatementReferenceMaster...
var ifStart = ifConditionStart.Find(s => true);
var ifEnd = ifConditionEnd.FindAll(s => true);
var loopStart = loopIndicatorStart.FindAll(l => true);
var loopEnd = loopIndicatorEnd.FindAll(l => true);
var callInternal = callInternalIndicationStart.Find(c => true);
var callExternal = callExternalIndicationStart.Find(c => true);
var indexPosition = -1;
var methodBusinessName = string.Empty;
string businessName = null;
var linesWithCommentedPart = programLineList.ToList();
programLineList = programLineList.Select(s => s.CheckCommentInStatement()).ToList();
stringBuilder.AppendLine("Started dump statement into database of file: " + icdFile.FilePath);
foreach (var line in programLineList)
{
indexPosition = indexPosition + 1;
if (string.IsNullOrEmpty(line))
{
continue;
}
if (indexPosition + 1 < programLineList.Count)
{
var nextLine = programLineList[indexPosition + 1];
if (!string.IsNullOrEmpty(nextLine) && lstAllGoSubs.Any(a => a.StartsWith(nextLine)))
{
methodBusinessName = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(line.ToLower());
continue;
}
if (linesWithCommentedPart[indexPosition].Contains("; *") ||
linesWithCommentedPart[indexPosition].Contains(";*"))
{
var lastOrDefault = linesWithCommentedPart[indexPosition].Split(';').LastOrDefault();
if (lastOrDefault != null)
{
businessName = lastOrDefault.Replace("*", "");
}
if (businessName != null)
{
businessName = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(businessName.ToLower());
businessName = businessName.Replace("&", "AND").Replace("&&", "AND").Replace("||", "OR");
}
}
}
if (line.StartsWith(lineCommentedIndicators.Find(x => x.StartIndicator != null).StartIndicator))
{
continue;
}
if (line.StartsWith("RETURN"))
{
var stmtReferenceMaster = new StatementReferenceMaster
{
FileId = icdFile.FileId,
ResolvedStatement = line,
OriginalStatement = line,
ClassCalled = null,
MethodName = null,
BusinessName = businessName,
DataOrObjectType = null,
MethodCalled = null,
VariableNameDeclared = null,
BaseCommandId = methodEnd.BaseCommandId,
PrimaryCommandId = methodEnd.PrimaryReferenceId,
ParsedOrNot = "Y",
ProjectId = projectId
};
await _codeVortoService.StatementReferenceMasterRepository.AddNewItem(stmtReferenceMaster);
businessName = string.Empty;
continue;
}
if (lstAllGoSubs.Any(a => line.StartsWith(a)))
{
var stmtReferenceMaster = new StatementReferenceMaster
{
FileId = icdFile.FileId,
ResolvedStatement = line,
OriginalStatement = line,
ClassCalled = null,
MethodName = line.Split(':').FirstOrDefault() + "()",
DataOrObjectType = null,
MethodCalled = null,
VariableNameDeclared = null,
BaseCommandId = 8,
PrimaryCommandId = 36,
ParsedOrNot = "Y",
ProjectId = projectId,
BusinessName = methodBusinessName
};
await _codeVortoService.StatementReferenceMasterRepository.AddNewItem(stmtReferenceMaster);
businessName = string.Empty;
methodBusinessName = string.Empty;
continue;
}
if (line.StartsWith(ifStart.StartIndicator))
{
var stmtReferenceMaster = new StatementReferenceMaster
{
FileId = icdFile.FileId,
ResolvedStatement = line,
OriginalStatement = line,
ClassCalled = null,
MethodName = null,
BusinessName = businessName,
DataOrObjectType = null,
MethodCalled = null,
VariableNameDeclared = null,
BaseCommandId = ifStart.BaseCommandId,
PrimaryCommandId = ifStart.PrimaryReferenceId,
ParsedOrNot = "Y",
ProjectId = projectId
};
await _codeVortoService.StatementReferenceMasterRepository.AddNewItem(stmtReferenceMaster);
businessName = string.Empty;
continue;
}
if ((line == "END ELSE") || (line == "ELSE"))
{
var stmtReferenceMaster = new StatementReferenceMaster
{
FileId = icdFile.FileId,
ResolvedStatement = line,
OriginalStatement = line,
ClassCalled = null,
MethodName = null,
BusinessName = businessName,
DataOrObjectType = null,
MethodCalled = null,
VariableNameDeclared = null,
BaseCommandId = 10,
PrimaryCommandId = 0,
ParsedOrNot = "Y",
ProjectId = projectId
};
await _codeVortoService.StatementReferenceMasterRepository.AddNewItem(stmtReferenceMaster);
businessName = string.Empty;
continue;
}
if (ifEnd.Any(l => line == l.StartIndicator))
{
var stmtReferenceMaster = new StatementReferenceMaster
{
FileId = icdFile.FileId,
ResolvedStatement = line,
OriginalStatement = line,
ClassCalled = null,
MethodName = null,
BusinessName = businessName,
DataOrObjectType = null,
MethodCalled = null,
VariableNameDeclared = null,
BaseCommandId = 2,
PrimaryCommandId = ifEnd.Find(s => line.StartsWith(s.StartIndicator)).PrimaryReferenceId,
ParsedOrNot = "Y",
ProjectId = projectId
};
await _codeVortoService.StatementReferenceMasterRepository.AddNewItem(stmtReferenceMaster);
businessName = string.Empty;
continue;
}
if (loopStart.Any(l => line.StartsWith(l.StartIndicator)) || line == "LOOP")
{
var stmtReferenceMaster = new StatementReferenceMaster
{
FileId = icdFile.FileId,
ResolvedStatement = line,
OriginalStatement = line,
ClassCalled = null,
MethodName = null,
BusinessName = businessName,
DataOrObjectType = null,
MethodCalled = null,
VariableNameDeclared = null,
BaseCommandId = line == "LOOP" ? 3 : loopStart.Find(s => line.StartsWith(s.StartIndicator)).BaseCommandId,
PrimaryCommandId = line == "LOOP" ? 62 :
loopStart.Find(s => line.StartsWith(s.StartIndicator)).PrimaryReferenceId,
ParsedOrNot = "Y",
ProjectId = projectId
};
await _codeVortoService.StatementReferenceMasterRepository.AddNewItem(stmtReferenceMaster);
businessName = string.Empty;
continue;
}
if (loopEnd.Any(l => line.StartsWith(l.StartIndicator)))
{
var stmtReferenceMaster = new StatementReferenceMaster
{
FileId = icdFile.FileId,
ResolvedStatement = line,
OriginalStatement = line,
ClassCalled = null,
MethodName = null,
BusinessName = businessName,
DataOrObjectType = null,
MethodCalled = null,
VariableNameDeclared = null,
BaseCommandId = loopEnd.Find(s => line.StartsWith(s.StartIndicator)).BaseCommandId,
PrimaryCommandId = loopEnd.Find(s => line.StartsWith(s.StartIndicator)).PrimaryReferenceId,
ParsedOrNot = "Y",
ProjectId = projectId
};
await _codeVortoService.StatementReferenceMasterRepository.AddNewItem(stmtReferenceMaster);
businessName = string.Empty;
continue;
}
if (line.StartsWith(callInternal.StartIndicator))
{
var methodName = line.CheckCommentInStatement();
var stmtReferenceMaster = new StatementReferenceMaster
{
FileId = icdFile.FileId,
ResolvedStatement = methodName,
OriginalStatement = methodName,
ClassCalled = null,
MethodName = null,
BusinessName = businessName,
DataOrObjectType = null,
MethodCalled = methodName.Split(' ').LastOrDefault() + "()",
VariableNameDeclared = null,
BaseCommandId = callInternal.BaseCommandId,
PrimaryCommandId = callInternal.PrimaryReferenceId,
ParsedOrNot = "Y",
ProjectId = projectId
};
await _codeVortoService.StatementReferenceMasterRepository.AddNewItem(stmtReferenceMaster);
businessName = string.Empty;
continue;
}
if (line.StartsWith(callExternal.StartIndicator + " "))
{
var stmtReferenceMaster = new StatementReferenceMaster
{
FileId = icdFile.FileId,
ResolvedStatement = line,
OriginalStatement = line,
ClassCalled = null,
MethodName = null,
BusinessName = businessName,
DataOrObjectType = null,
MethodCalled = null,
VariableNameDeclared = null,
BaseCommandId = callExternal.BaseCommandId,
PrimaryCommandId = callExternal.PrimaryReferenceId,
ParsedOrNot = "Y",
ProjectId = projectId
};
await _codeVortoService.StatementReferenceMasterRepository.AddNewItem(stmtReferenceMaster);
businessName = string.Empty;
}
else
{
var stmtReferenceMaster = new StatementReferenceMaster
{
FileId = icdFile.FileId,
ResolvedStatement = line,
OriginalStatement = line,
ClassCalled = null,
MethodName = null,
BusinessName = businessName,
DataOrObjectType = null,
MethodCalled = null,
VariableNameDeclared = null,
BaseCommandId = 0,
PrimaryCommandId = 0,
ParsedOrNot = "Y",
ProjectId = projectId
};
await _codeVortoService.StatementReferenceMasterRepository.AddNewItem(stmtReferenceMaster);
businessName = string.Empty;
}
}
#endregion
var statmentRefEnd = universeBasicV1.PrepareStatementReferenceMasterEnd(icdFile, 43);
await _codeVortoService.StatementReferenceMasterRepository.BulkInsert(statmentRefEnd);
#region Update ClassCalled field for StatementReferenceMaster...
stringBuilder.AppendLine("========================================================================================");
stringBuilder.AppendLine("Started update classcalled and methodcalled for basecommandId = 6 & 19 for project: " + projectId);
/* Added shubhangi */
var execOrCallSql = " Select sm.* from StatementReferenceMaster as sm " +
" Inner Join FileMaster as fm ON sm.FileId = fm.FileId Where sm.ProjectId IN (" +
projectId + "," + commanClassProjId +
" ) AND fm.Processed = 0 AND sm.BaseCommandId IN (6, 19); ";
var callExternals = await baseCommandReferenceRepository
.GetDataFromSqlQuery <StatementReferenceMaster>(execOrCallSql).ConfigureAwait(false);
foreach (var cExternal in callExternals)
{
if (cExternal.BaseCommandId == 6)
{
string pgName;
if (cExternal.OriginalStatement.ContainsAll("@", "(", ")"))
{
pgName = cExternal.OriginalStatement.Split('@').LastOrDefault();
if (pgName != null)
{
pgName = pgName.Split('(').FirstOrDefault();
}
}
else
{
pgName = cExternal.OriginalStatement.Split('@').LastOrDefault();
}
var pName =
copyOfFileMaster.ToList().Where(f => !string.IsNullOrEmpty(pgName) &&
f.FileName.StartsWith(pgName) &&
(f.FileTypeExtensionId == 9)).ToList();
if (!pName.Any())
{
continue;
}
var projectDetatils = _codeVortoService.ProjectMasterRepository.GetItem(pName[0].ProjectId);
var pNameNew = projectDetatils.ProjectName;
var pPathNew = projectDetatils.PhysicalPath;
var className = pName[0].FilePath.Replace(pPathNew + "\\", "")
.Replace(pName[0].FileName, "").Replace("\\", ".");
var fileName = Path.GetFileNameWithoutExtension(pName[0].FilePath);
// Use it later...
var classNameDeclared = pNameNew + "." + className + fileName;
cExternal.ClassCalled = classNameDeclared;
await _codeVortoService.StatementReferenceMasterRepository
.UpdateItem(cExternal).ConfigureAwait(false);
continue;
}
if (cExternal.BaseCommandId == 19)
{
var fileId = cExternal.FileId;
var pName =
copyOfFileMaster.ToList().Where(f => f.FileId == fileId).ToList();
if (pName.Count == 0) // Added shubhangi
{
var fileMasterNew = await _codeVortoService.FileMasterRepository
.GetAllItems(p => p.ProjectId == projectId || p.ProjectId == commanClassProjId);
copyOfFileMaster =
new List <FileMaster>(fileMasterNew as FileMaster[] ?? fileMasterNew.ToArray());
pName =
copyOfFileMaster.ToList().Where(f => f.FileId == fileId).ToList();
}
var projectDetatils = _codeVortoService.ProjectMasterRepository.GetItem(pName[0].ProjectId);
var pNameNew = projectDetatils.ProjectName;
var pPathNew = projectDetatils.PhysicalPath;
var classNameProgram = pName[0].FilePath.Replace(pPathNew + "\\", "")
.Replace(pName[0].FileName, "").Replace("\\", ".");
var fileNameProgram = Path.GetFileNameWithoutExtension(pName[0].FilePath);
// Use it later...
var classNameDeclaredProgram = pNameNew + "." + classNameProgram + fileNameProgram;
cExternal.ClassNameDeclared = classNameDeclaredProgram;
await _codeVortoService.StatementReferenceMasterRepository.UpdateItem(cExternal);
}
}
#endregion
#region Update Method called for base command id = 6 in Jcl and program...
stringBuilder.AppendLine("========================================================================================");
stringBuilder.AppendLine("Started update methodcalled for Jcl and program basecommandId = 6 for project: " + projectId);
var execSql =
" Select sm.* from StatementReferenceMaster as sm " +
" Inner Join FileMaster as fm ON fm.FileId = sm.FileId Where sm.ProjectId = " + projectId +
" AND sm.BaseCommandId = 6 " +
" AND fm.Processed = 0 AND sm.ClassCalled is not null;";
var execName = await baseCommandReferenceRepository
.GetDataFromSqlQuery <StatementReferenceMaster>(execSql).ConfigureAwait(false);
foreach (var constructor in execName)
{
// ReSharper disable once RedundantAssignment
var fName = constructor.ClassCalled.Split('.').LastOrDefault().Trim() + ".pgm";
var allCheckFiles = await _codeVortoService.FileMasterRepository
.GetAllItems(f => (f.ProjectId == projectId) && (f.FileName == fName)).ConfigureAwait(false);
foreach (var files in allCheckFiles)
{
var methodSql = " SELECT DISTINCT sm.* from statementreferencemaster as sm " +
" INNER JOIN FileMaster as fm where sm.FileId = " + files.FileId +
" AND fm.SolutionId = " + files.SolutionId + " AND sm.BaseCommandId = 8;";
var methodName = await baseCommandReferenceRepository
.GetDataFromSqlQuery <StatementReferenceMaster>(methodSql).ConfigureAwait(false);
foreach (var statementReference in methodName)
{
if (string.IsNullOrEmpty(statementReference.MethodName))
{
continue;
}
var pName =
copyOfFileMaster.ToList().Where(f => f.FileId == statementReference.FileId).ToList();
var projectDetails1 =
_codeVortoService.ProjectMasterRepository.GetItem(pName[0].ProjectId);
var pNameNew = projectDetails1.ProjectName;
var pPathNew = projectDetails1.PhysicalPath;
var classNameProgram = pName[0].FilePath.Replace(pPathNew + "\\", "")
.Replace(pName[0].FileName, "").Replace("\\", ".");
var fileNameProgram = Path.GetFileNameWithoutExtension(pName[0].FilePath);
// Use it later...
var classCalled = pNameNew + "." + classNameProgram + fileNameProgram;
constructor.ClassCalled = classCalled;
constructor.MethodCalled = statementReference.MethodName;
await _codeVortoService.StatementReferenceMasterRepository.UpdateItem(constructor).ConfigureAwait(false);
break;
}
}
}
#endregion
#region Update field for basecommandId = 30
stringBuilder.AppendLine("========================================================================================");
stringBuilder.AppendLine("Started update field for basecommandId = 30 for project: " + projectId);
if (!string.IsNullOrEmpty(icdFile.FilePath))
{
var fileId = icdFile.FileId;
var execSqlPrgm = " Select * from StatementReferenceMaster where ProjectId =" + projectId +
" AND FileId = " + fileId + " AND BaseCommandId IN (0, 1);";
var execNamePrgm =
await baseCommandReferenceRepository.GetDataFromSqlQuery <StatementReferenceMaster>(execSqlPrgm);
var indexPositionPrgm = -1;
foreach (var exNmPg in execNamePrgm)
{
indexPositionPrgm = indexPositionPrgm + 1;
if (exNmPg.BaseCommandId != 1)
{
continue;
}
if ((exNmPg.OriginalStatement != "IF FOUND THEN") &&
(exNmPg.OriginalStatement != "IF FOUND") &&
(exNmPg.OriginalStatement != "IF NOT SUCCESS THEN") &&
(exNmPg.OriginalStatement != "IF NOT-SUCCESS THEN") &&
(exNmPg.OriginalStatement != "IF SUCCESS THEN") &&
(exNmPg.OriginalStatement != "IF NOT FOUND THEN") &&
(exNmPg.OriginalStatement != "IF NOT-FOUND THEN") &&
(exNmPg.OriginalStatement != "IF NOT FOUND") &&
(exNmPg.OriginalStatement != "IF NOT-FOUND"))
{
continue;
}
var aboveLine = execNamePrgm[indexPositionPrgm - 1];
aboveLine.BaseCommandId = 30;
await _codeVortoService.StatementReferenceMasterRepository.UpdateItem(aboveLine);
}
}
#endregion
#region Update Include program File Processed
stringBuilder.AppendLine("========================================================================================");
stringBuilder.AppendLine("Started update Include program File Processed for project: " + projectId + ", and file is:" + icdFile.FileName + "");
icdFile.DoneParsing = 1;
icdFile.ProjectMaster = null;
await _codeVortoService.FileMasterRepository.UpdateItem(icdFile).ConfigureAwait(false);
if (icdFile.FileTypeExtensionId != 12)
{
return(Ok("Done"));
}
icdFile.Processed = 1;
icdFile.ProjectMaster = null;
await _codeVortoService.FileMasterRepository.UpdateItem(icdFile).ConfigureAwait(false);
#endregion
LogMessage.WriteLogMessage(stringBuilder);
return(Ok("Done"));
}
}
public UserMasterController(ICodeVortoService codeVortoService)
{
_codeVortoService = codeVortoService;
}
public CobolBatchProcessingController(ICodeVortoService codeVortoService)
{
_codeVortoService = codeVortoService;
}
//public async Task<IHttpActionResult> GetAllStartNodeDetails(int projectId, int stmtId)
public async Task <IHttpActionResult> GetAllStartingPoints(int projectId, int stmtId, string opt)
{
using (_codeVortoService = new CodeVortoService())
{
var lstTreeViewData = new List <TreeViewData>();
var lstTreeView = new List <TreeView>();
var secondTab = new List <TreeView>();
var lstNodes = new List <Node>();
var lstLinks = new List <Link>();
var startClasses =
await _codeVortoService.ActionWorkflowsRepository.GetAllItems(p => p.MethodStatementId != 0);
var clsName = (from s in startClasses where s.MethodStatementId == stmtId select s).ToList().First();
var autoNodeId = 500;
lstNodes.Add(new Node
{
Name = clsName.OriginObject,
Id = 1111,
ParentId = 0,
ShapeId = "RoundRect",
Color = "#28c965",
Height = "15",
Width = clsName.OriginObject.Length.ToString()
});
object[] parameters =
{
new MySqlParameter("@stmtId", MySqlDbType.Int32)
{
Value = stmtId
},
new MySqlParameter("@startBaseCommandId", MySqlDbType.Int32)
{
Value = 8
},
new MySqlParameter("@endBaseCommandId", MySqlDbType.Int32)
{
Value = 9
}
};
var workflowRef = _codeVortoService.StatementReferenceMasterRepository
.ExecuteStoreProcedure <StatementReferenceMaster>("SpGetAnyGenericBlock", parameters)
.ContinueWith(t => t.Result).Result;
var treeStackStart = new Stack <StatementReferenceMaster>();
treeStackStart.Push(workflowRef.FirstOrDefault());
const string gName = "graphName";
var mm = 1;
var graphId = gName + mm;
var bId = workflowRef[0].BaseCommandId;
lstTreeView.Add(new TreeView
{
GraphId = 1.ToString(),
GraphName = clsName.OriginObject,
HasChild = true,
ParentId = "-1"
});
lstTreeView.Add(new TreeView
{
GraphId = gName + mm,
GraphName = "<span class='nodeToBold'>" + workflowRef[0].OriginalStatement + "</span>",
HasChild = true,
ParentId = 1.ToString(),
BaseCommandId = bId
});
workflowRef.RemoveAt(0);
var linkCounter = 1;
var ifCounter = 0;
var done = false;
foreach (var statementM in workflowRef)
{
//This is call external and will have its child tree from here...
var autoInt = 5;
if (statementM.PrimaryCommandId == 1)
{
ifCounter++;
}
if ((statementM.PrimaryCommandId == 1) && !done)
{
done = true;
graphId = gName + mm + 1;
var treeView = new TreeView
{
GraphId = graphId,
GraphName = statementM.OriginalStatement,
HasChild = true,
SpriteCssClass = "",
ParentId = gName + mm,
BaseCommandId = 1
};
lstTreeView.Add(treeView);
lstNodes.Add(new Node
{
Id = autoNodeId,
Name = statementM.OriginalStatement,
ShapeId = "Decision",
Color = "#f5bd6a",
Height = "15",
Width = statementM.OriginalStatement.Length.ToString()
});
lstLinks.Add(new Link
{
Origin = 1111,
Target = autoNodeId,
LinkText = "[ " + linkCounter + " ] " +
statementM.OriginalStatement
});
autoNodeId++;
linkCounter++;
continue;
}
if (statementM.PrimaryCommandId == 2)
{
ifCounter--;
if (ifCounter == 0)
{
done = true;
graphId = gName + mm;
}
}
if (statementM.BaseCommandId == 6)
{
if (statementM.ClassCalled != null)
{
var className = statementM.ClassCalled.Split('.').Last();
object[] parametersExp =
{
new MySqlParameter("@clsName", MySqlDbType.VarChar)
{
Value = className
}
};
var callExtExpandedCode = _codeVortoService.StatementReferenceMasterRepository
.ExecuteStoreProcedure <StatementReferenceMaster>("SpGetClassMethods", parametersExp)
.ContinueWith(t => t.Result).Result;
lstTreeView.Add(new TreeView
{
ParentId = graphId,
GraphId = statementM.StatementId.ToString(),
HasChild = true,
GraphName = "<span class='nodeToBold'>" + statementM.OriginalStatement + "</span>",
BaseCommandId = statementM.BaseCommandId
});
var sz1 = (from k in lstNodes where k.Name == statementM.ClassCalled select k).ToList();
if (!sz1.Any())
{
Node lastNode = null;
if (lstNodes.Last().ShapeId == "Decision")
{
lastNode = lstNodes.Last();
}
lstNodes.Add(new Node
{
Id = autoNodeId,
Name = statementM.ClassCalled,
ShapeId = "RoundRect",
Color = "#f5bd6a",
Height = "15",
Width = statementM.ClassCalled.Length.ToString()
});
if (lastNode != null)
{
lstLinks.Add(new Link
{
Origin = autoNodeId - 1,
Target = autoNodeId,
LinkText = "[ " + linkCounter + " ] Yes"
});
}
else
{
lstLinks.Add(new Link
{
Origin = 1111,
Target = autoNodeId,
LinkText = "[ " + linkCounter + " ] " +
statementM.MethodCalled.Substring(0,
statementM.MethodCalled.IndexOf('('))
});
}
autoNodeId++;
linkCounter++;
}
else
{
var k = statementM.MethodCalled.Substring(0, statementM.MethodCalled.IndexOf('('));
var tnk = (from l in lstLinks
where (l.Origin == 1111) && (l.LinkText == k)
select l).ToList();
if (!tnk.Any())
{
}
//linkCounter++;
}
// Now try to find out body for external call...
if (callExtExpandedCode.Count == 0)
{
lstTreeView.Add(new TreeView
{
ParentId = statementM.StatementId.ToString(),
GraphId = "1111111",
HasChild = true,
GraphName = "<span class='nodemissingelement'> Definition Missing </span>",
BaseCommandId = 25
});
}
else
{
foreach (var statmentM in callExtExpandedCode)
{
if (!statementM.MethodCalled.StartsWith(statmentM.MethodName))
{
continue;
}
var blockStmtId = statmentM.StatementId;
object[] bParameters =
{
new MySqlParameter("@stmtId", MySqlDbType.Int32)
{
Value = blockStmtId
},
new MySqlParameter("@startBaseCommandId", MySqlDbType.Int32)
{
Value = 8
},
new MySqlParameter("@endBaseCommandId", MySqlDbType.Int32)
{
Value = 9
}
};
var stmtsBlick = _codeVortoService.StatementReferenceMasterRepository
.ExecuteStoreProcedure <StatementReferenceMaster>("SpGetAnyGenericBlock",
bParameters).Result;
foreach (var block in stmtsBlick)
{
if (block.BaseCommandId == 6)
{
lstTreeView.Add(new TreeView
{
ParentId = statementM.StatementId.ToString(),
GraphId = block.StatementId + "_" + autoInt,
HasChild = false,
GraphName = block.OriginalStatement,
BaseCommandId = block.BaseCommandId
});
var sz =
(from s in lstNodes where s.Name == block.ClassCalled select s).ToList();
if (!sz.Any())
{
lstNodes.Add(new Node
{
Id = autoNodeId,
Name = block.ClassCalled,
BaseCommandId = statementM.BaseCommandId,
ShapeId = "RoundRect",
Color = "#f5bd6a",
Height = "15",
Width = block.ClassCalled.Length.ToString()
});
var block1 = block;
var asz =
(from n in lstNodes where n.Name == block1.ClassCalled select n)
.ToList();
var ss =
(from t in lstNodes where t.Name == statementM.ClassCalled select t)
.ToList();
lstLinks.Add(new Link
{
Origin = ss.First().Id,
Target = asz.First().Id,
LinkText = "[ " + linkCounter + " ] " +
block.MethodCalled.Substring(0,
block.MethodCalled.IndexOf('('))
});
autoNodeId++;
linkCounter++;
}
else
{
var asz =
(from n in lstNodes where n.Name == statementM.ClassCalled select n)
.ToList();
lstLinks.Add(new Link
{
Origin = asz.First().Id,
Target = sz.First().Id,
LinkText = "[ " + linkCounter + " ] " +
block.MethodCalled.Substring(0,
block.MethodCalled.IndexOf('('))
});
linkCounter++;
}
lstTreeView = AppendNodeToExisting(block.StatementId + "_" + autoInt,
lstTreeView, block, lstLinks, lstNodes, autoNodeId, ref linkCounter);
autoInt++;
//lstTreeView.AddRange(result);
}
else
{
lstTreeView.Add(new TreeView
{
ParentId = statementM.StatementId.ToString(),
GraphId = block.StatementId.ToString(),
HasChild = false,
GraphName = block.OriginalStatement,
BaseCommandId = block.BaseCommandId
});
}
}
}
}
}
else
{
object[] bParameters =
{
new MySqlParameter("@stmtId", MySqlDbType.Int32)
{
Value = statementM.StatementId
},
new MySqlParameter("@startBaseCommandId", MySqlDbType.Int32)
{
Value = 8
},
new MySqlParameter("@endBaseCommandId", MySqlDbType.Int32)
{
Value = 9
}
};
var stmtsBlock = _codeVortoService.StatementReferenceMasterRepository
.ExecuteStoreProcedure <StatementReferenceMaster>("SpGetAnyGenericBlock",
bParameters).Result;
if (stmtsBlock.Count == 0)
{
lstTreeView.Add(new TreeView
{
ParentId = graphId,
GraphId = "222222",
HasChild = false,
GraphName = statementM.OriginalStatement,
BaseCommandId = 25
});
}
foreach (var block in stmtsBlock)
{
if (block.BaseCommandId == 6)
{
lstTreeView.Add(new TreeView
{
ParentId = graphId,
GraphId = block.StatementId + "_" + autoInt,
HasChild = false,
GraphName = block.OriginalStatement,
BaseCommandId = block.BaseCommandId
});
lstTreeView = AppendNodeToExisting(block.StatementId + "_" + autoInt,
lstTreeView, block, lstLinks, lstNodes, autoNodeId, ref linkCounter);
autoInt++;
linkCounter++;
//lstTreeView.AddRange(result);
}
else
{
lstTreeView.Add(new TreeView
{
ParentId = graphId,
GraphId = block.StatementId.ToString(),
HasChild = false,
GraphName = block.OriginalStatement,
BaseCommandId = block.BaseCommandId
});
}
autoInt++;
}
}
}
else
{
var treeView = new TreeView
{
GraphId = statementM.StatementId.ToString(),
GraphName = statementM.OriginalStatement,
HasChild = false,
SpriteCssClass = "",
ParentId = graphId,
BaseCommandId = bId
};
lstTreeView.Add(treeView);
}
}
var copyOfLinks = lstLinks;
foreach (var node in lstNodes)
{
var childNodes = (from lnk in lstLinks
where lnk.Origin == node.Id
select lnk.Target
into p
select lstNodes.Find(n => n.Id == p)).ToList();
if (childNodes.Count > 1)
{
var duplicates = childNodes.GroupBy(x => x)
.Where(g => g.Count() > 1).Select(g => g.Key).ToList();
if ((duplicates.Count > 0) && (duplicates[0] != null))
{
var links =
(from h in lstLinks
where (h.Origin == node.Id) && (h.Target == duplicates.First().Id)
select h)
.ToList();
if (!links.Any())
{
continue;
}
var linkText = links.Aggregate(string.Empty,
(current, jk) => current + jk.LinkText + ", ");
linkText = linkText.Substring(0, linkText.LastIndexOf(','));
links.First().LinkText = linkText;
foreach (var l in links)
{
if (l.LinkText == linkText)
{
continue;
}
copyOfLinks.Remove(l);
}
}
}
}
var treeViewData = new TreeViewData(lstTreeView)
{
Links = copyOfLinks,
Nodes = lstNodes
};
lstTreeViewData.Add(treeViewData);
//var items = lstTreeView.ToList().FindAll(b => b.BaseCommandId == 6
// || b.BaseCommandId == 25).ToList();
secondTab.Add(lstTreeView.ElementAt(0));
secondTab.Add(lstTreeView.ElementAt(1));
//TreeViewData treeViewDataNew = new TreeViewData(items);
secondTab.AddRange(
lstTreeView.Where(
item => (item.BaseCommandId == 6) || (item.BaseCommandId == 25) || (item.BaseCommandId == 1)));
var treeViewDataNew = new TreeViewData(secondTab);
lstTreeViewData.Add(treeViewDataNew);
return(Ok(lstTreeViewData));
}
}
public WorkspaceWorkflowController(ICodeVortoService codeVortoService)
{
_codeVortoService = codeVortoService;
}
public async Task <IHttpActionResult> GenerateWorkflowDiagram(int projectId)
{
using (_codeVortoService = new CodeVortoService())
{
var lstNodes = new List <Node>();
var workflowRef1 = await _codeVortoService.ActionWorkflowsRepository
.GetDataFromSqlQuery <ActionWorkflows>(
" SELECT * FROM codevorto.actionworkflows where ProjectId = " + projectId + " ;");
int?startId = 0;
if (workflowRef1 != null)
{
startId = workflowRef1[0].MethodStatementId;
}
var mySqlQuery = " Select * from statementreferencemaster where StatementId Between " +
" ( Select StatementId From StatementReferenceMaster Where BaseCommandId = 8 AND StatementId >= " +
startId + " LIMIT 1 ) ANd " +
" (Select StatementId From StatementReferenceMaster Where BaseCommandId = 9 AND StatementId >= " +
startId + " LIMIT 1) AND StatementId > " + startId + ";";
var workflowRef = await _codeVortoService.StatementReferenceMasterRepository
.GetDataFromSqlQuery <StatementReferenceMaster>(mySqlQuery);
var allClassDeclarations = await _codeVortoService.StatementReferenceMasterRepository
.GetDataFromSqlQuery <StatementReferenceMaster>(
"SELECT * FROM StatementReferenceMaster where ClassNameDeclared IS NOT NULL group by ClassNameDeclared;");
var classCollection =
allClassDeclarations.FindAll(s => s.ClassNameDeclared != null);
//var lstTreeView = new List<TreeView>();
var done = false;
foreach (var cls in classCollection)
{
if (done)
{
break;
}
foreach (var workFlow in workflowRef)
{
if (!workFlow.OriginalStatement.Contains("New " + cls.ClassNameDeclared + "()"))
{
continue;
}
var newStartPoint = workFlow;
var node = new Node
{
Id = newStartPoint.StatementId,
Name = "New " + cls.ClassNameDeclared + "()",
ShapeId = "RoundRect",
Color = "green",
StatementTypeId = newStartPoint.StatementId
};
lstNodes.Add(node);
done = true;
break;
}
}
//var statementRef1 = await _codeVortoService.StatementReferenceMasterRepository
// .GetEntityData<StatementReferenceMaster>(s => s.StatementId == workflowRef[0].StatementId);
var onStartSql =
"Select * from statementreferencemaster where MethodName = 'OnStart';";
var stmtMaster =
await _codeVortoService.StatementReferenceMasterRepository
.GetDataFromSqlQuery <StatementReferenceMaster>(onStartSql);
var methodQuery = " Select * from statementreferencemaster where StatementId Between " +
" ( Select StatementId From StatementReferenceMaster Where BaseCommandId = 8 AND StatementId >= " +
" " + stmtMaster[0].StatementId + " LIMIT 1 ) ANd " +
" (Select StatementId From StatementReferenceMaster Where BaseCommandId = 9 AND StatementId >= " +
" " + stmtMaster[0].StatementId + " LIMIT 1) AND StatementId >= " +
stmtMaster[0].StatementId + " ; ";
var statementMaster = await _codeVortoService.StatementReferenceMasterRepository
.GetDataFromSqlQuery <StatementReferenceMaster>(methodQuery);
var tempData = statementMaster;
foreach (var statementReference in statementMaster)
{
if (lstNodes.Exists(l => l.Name == statementReference.ClassCalled))
{
continue;
}
if (statementReference.BaseCommandId == 11) // Method Declatarion
{
}
if (statementReference.BaseCommandId == 5) // Call Internal
{
var node = new Node
{
Name = statementReference.ClassCalled,
Id = statementReference.StatementId,
Color = "red",
ShapeId = "RoundRect",
StatementTypeId = statementReference.StatementId
};
lstNodes.Add(node);
}
else if (statementReference.BaseCommandId == 3) // Loop
{
var node = new Node
{
Name = statementReference.VariableNameDeclared,
Id = statementReference.StatementId,
Color = "red",
ShapeId = "Rectangle",
StatementTypeId = statementReference.StatementId
};
lstNodes.Add(node);
}
else if (statementReference.BaseCommandId == 1) // IF
{
var ifString = statementReference.OriginalStatement.Split(new[] { "If " }
, StringSplitOptions.RemoveEmptyEntries);
var condition = ifString[0].Split(new[] { " Then" }, StringSplitOptions.RemoveEmptyEntries)[0];
var node = new Node
{
Name = condition,
Id = statementReference.StatementId,
Color = "#f4b183",
ShapeId = "Decision",
StatementTypeId = statementReference.StatementId
};
lstNodes.Add(node);
}
else if (statementReference.BaseCommandId == 6) // Call External
{
var node = new Node
{
Name = statementReference.VariableNameDeclared,
Id = statementReference.StatementId,
Color = "purple",
ShapeId = "RoundRect",
StatementTypeId = statementReference.StatementId
};
lstNodes.Add(node);
}
}
var lstLinks = new List <Link>();
foreach (var stmtMasterCopy in tempData)
{
if (stmtMasterCopy.BaseCommandId == 8)
{
//var reference = abc;
//var stmtMasterNew = await _codeVortoService.StatementReferenceMasterRepository
// .FindItem<StatementReferenceMaster>(s => s.MethodCalled == reference.MethodCalled);
var link = new Link
{
LinkText = stmtMasterCopy.MethodName,
Origin = lstNodes.First().Id,
Target = 244
};
lstLinks.Add(link);
}
else if (stmtMasterCopy.BaseCommandId == 5)
{
var destNode =
lstNodes.Find(n => (n.Name == stmtMasterCopy.ClassCalled) && (n.ShapeId == "RoundRect") &&
(n.Id != stmtMasterCopy.StatementId));
if (destNode == null)
{
continue;
}
var link = new Link
{
Origin = lstNodes.First().Id,
Target = destNode.Id,
LinkText = stmtMasterCopy.MethodCalled
};
lstLinks.Add(link);
}
}
var lstFlowcharts = new FlowChart
{
Nodes = lstNodes,
Links = lstLinks
};
return(Ok(lstFlowcharts));
}
}
public List <TreeView> AppendNodeToExisting(string statementId, List <TreeView> currentTreeView,
StatementReferenceMaster statementM, List <Link> lstLinks, List <Node> lstNodes, int autoNodeId,
ref int linkCounter)
{
using (_codeVortoService = new CodeVortoService())
{
var className = statementM.ClassCalled.Split('.').Last();
object[] parametersExp =
{
new MySqlParameter("@clsName", MySqlDbType.VarChar)
{
Value = className
}
};
var callExtExpandedCode = _codeVortoService.StatementReferenceMasterRepository
.ExecuteStoreProcedure <StatementReferenceMaster>("SpGetClassMethods", parametersExp)
.ContinueWith(t => t.Result).Result;
if (callExtExpandedCode.Count == 0)
{
var item = currentTreeView.Find(p => p.ParentId == statementId);
if (item == null)
{
currentTreeView.Add(new TreeView
{
ParentId = statementId,
GraphId = "11d11111",
HasChild = true,
GraphName = "<span class='nodemissingelement'> Definition Missing </span>",
BaseCommandId = 25
});
}
}
else
{
foreach (var statementK in callExtExpandedCode)
{
if (!statementM.MethodCalled.StartsWith(statementK.MethodName))
{
continue;
}
var blockStmtId = statementK.StatementId;
object[] bParameters =
{
new MySqlParameter("@stmtId", MySqlDbType.Int32)
{
Value = blockStmtId
},
new MySqlParameter("@startBaseCommandId", MySqlDbType.Int32)
{
Value = 8
},
new MySqlParameter("@endBaseCommandId", MySqlDbType.Int32)
{
Value = 9
}
};
var stmtsBlock = _codeVortoService.StatementReferenceMasterRepository
.ExecuteStoreProcedure <StatementReferenceMaster>("SpGetAnyGenericBlock", bParameters).Result;
foreach (var block in stmtsBlock)
{
if (block.BaseCommandId == 6)
{
currentTreeView.Add(new TreeView
{
ParentId = statementId,
GraphId = block.StatementId + "_" + statementId,
HasChild = false,
GraphName = block.OriginalStatement,
BaseCommandId = block.BaseCommandId
});
var block1 = block;
var sz = (from t in lstNodes where t.Name == block1.ClassCalled select t).ToList();
if (!sz.Any())
{
lstNodes.Add(new Node
{
Id = autoNodeId,
Name = block.ClassCalled,
ParentId = 0,
BaseCommandId = block.BaseCommandId,
ShapeId = "RoundRect",
Color = "#f5bd6a",
Height = "15",
Width = "100"
});
//var sz1 = (from f in lstNodes where f.Name == statementM.ClassCalled select f).ToList();
lstLinks.Add(new Link
{
Target = statementM.StatementId,
Origin = lstNodes.Last().Id,
LinkText = "[ " + linkCounter + " ] " +
statementM.MethodCalled.Substring(0,
statementM.MethodCalled.IndexOf('('))
});
linkCounter++;
}
else
{
var asz = (from n in lstNodes where n.Name == statementM.ClassCalled select n)
.ToList();
lstLinks.Add(new Link
{
Origin = asz.First().Id,
Target = sz.First().Id,
LinkText = "[ " + linkCounter + " ] " +
block.MethodCalled.Substring(0, block.MethodCalled.IndexOf('('))
});
linkCounter++;
}
currentTreeView = AppendNodeToExisting(block.StatementId + "_" + statementId,
currentTreeView, block, lstLinks, lstNodes, autoNodeId, ref linkCounter);
}
else
{
currentTreeView.Add(new TreeView
{
ParentId = statementId,
GraphId = block.StatementId.ToString(),
HasChild = false,
GraphName = block.OriginalStatement,
BaseCommandId = block.BaseCommandId
});
}
}
}
}
return(currentTreeView);
}
}
public async Task <HttpResponseMessage> StartProcessUbProject(int projectId)
{
using (_codeVortoService = new CodeVortoService())
{
var projectMasterRepository = new ProjectMasterRepository(new AppDbContext());
var projectDetails = projectMasterRepository.GetItem(projectId);
if (projectDetails == null)
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new StringContent("Project not found: " + projectId)
});
}
var entensionList =
await _codeVortoService.FileTypeExtensionRepository.GetAllListItems(
p => p.LanguageId == projectDetails.LanguageId).ConfigureAwait(true);
var strExtensions = new List <string>();
strExtensions.AddRange(entensionList.Select(extension => extension.FileExtension));
var lstFileMasters = new List <FileMaster>();
var projectPath = projectDetails.PhysicalPath;
var solutionId = projectDetails.SolutionId;
var directoryList = new List <string> {
projectPath
};
var ignoredFile =
await projectMasterRepository.GetAllIgnoredFiles <IgnoreFiles>(projectDetails.LanguageId)
.ConfigureAwait(false);
var regexPattern = new Regex(@"RECEIVE\s+MAP|SEND\s+MAP");
foreach (var directory in directoryList)
{
try
{
var allFiles = Directory.GetFiles(directory, "*.*", SearchOption.AllDirectories)
.Where(s => strExtensions.Any(s.EndsWith));
var enumerator = allFiles.GetEnumerator();
while (enumerator.MoveNext())
{
var currentFile = enumerator.Current;
if (ignoredFile.Any(f => f.FileName == Path.GetFileName(currentFile)))
{
continue;
}
if (currentFile == null)
{
continue;
}
var fileLines = File.ReadAllLines(currentFile).ToList();
var exist = fileLines.Any(f => regexPattern.IsMatch(f));
var fileType = exist ? "Online" : "Batch";
var lineCount = fileLines.Count(line => !string.IsNullOrWhiteSpace(line));
var fileName = Path.GetFileName(currentFile);
if (string.IsNullOrEmpty(fileName))
{
continue;
}
var extension = Path.GetExtension(currentFile);
var extensionId =
entensionList.First(e => e.FileExtension == extension).FileTypeExtensionId;
var fileMaster = new FileMaster
{
FileId = 0,
FileName = fileName,
FilePath = currentFile,
FileTypeExtensionId = extensionId,
ProjectId = projectId,
SolutionId = solutionId,
DoneParsing = 0,
LinesCount = lineCount,
FileType = fileType
};
lstFileMasters.Add(fileMaster);
}
enumerator.Dispose();
await
_codeVortoService.FileMasterRepository.BulkInsert(lstFileMasters).ConfigureAwait(false);
}
catch (Exception exception)
{
Console.WriteLine(exception.InnerException);
return(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content =
new ObjectContent(typeof(Exception), exception.InnerException,
new JsonMediaTypeFormatter())
});
}
}
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent("Cobol processing is done")
});
}
}
