public FormController(IManager manager, IDataModelManager dataModelManager, IDocumnentManager documentManager, IService service)
{
_manager = manager;
_dataModelManager = dataModelManager;
_documentManager = documentManager;
_service = service;
}
/// <summary>
/// Get Responsible Details
/// </summary>
/// <param name="manager"></param>
/// <returns></returns>
public static DataTable GetResponsibleDetails(IManager manager, IDataModelManager dataModelManager)
{
var data = GetResponsibleFullDetails(manager, dataModelManager);
data.Columns.Remove("ManagerId");
return(data);
}
public ServicesController(IManager manager, IService service, IDCRService dCRService, IDataModelManager dataModelManager)
{
_manager = manager;
_service = service;
_dcrService = dCRService;
_dataModelManager = dataModelManager;
}
/// <summary>
/// Update Event Type Data
/// </summary>
/// <param name="instanceId"></param>
/// <param name="manager"></param>
public static void UpdateEventTypeData(dynamic instanceId, IManager manager, IDataModelManager dataModelManager)
{
dataModelManager.GetDefaultDataModel(Enums.SQLOperation.SP, "AddEventTypeData");
dataModelManager.AddParameter("InstanceId", Enums.ParameterType._int, instanceId);
manager.ExecuteStoreProcedure(dataModelManager.DataModel);
}
/// <summary>
/// Get Instance Xml
/// </summary>
/// <param name="insstanceId"></param>
/// <returns></returns>
public static string GetInstanceXML(string insstanceId, IManager manager, IDataModelManager dataModelManager)
{
dataModelManager.GetDefaultDataModel(Enums.SQLOperation.SELECT, "Instance");
dataModelManager.AddResultSet(new List <string>()
{
"DCRXML"
});
if (!string.IsNullOrEmpty(insstanceId))
{
dataModelManager.AddFilter("Id", Enums.ParameterType._int, insstanceId, Enums.CompareOperator.equal, Enums.LogicalOperator.none);
}
else
{
return(string.Empty);
}
var data = manager.SelectData(dataModelManager.DataModel);
if (data.Rows.Count > 0)
{
return(data.Rows[0]["DCRXML"].ToString());
}
else
{
return(string.Empty);
}
}
public RecordsController(IManager manager, IService service, IDCRService dCRService, IDataModelManager dataModelManager, IDocumnentManager documentManager)
{
_manager = manager;
_service = service;
_dCRService = dCRService;
_dataModelManager = dataModelManager;
_documentManager = documentManager;
}
public ContractManager(IJSRuntime jsRuntime, HttpClient httpClient,
IConverterService converterService, IContractStorage contractStorage,
SaveManager saveManager, IDataModelManager dataModelManager, IUserModelManager userModelManager,
IProcessModelManager processModelManager)
{
_jsRuntime = jsRuntime;
_converterService = converterService;
_httpClient = httpClient;
_contractStorage = contractStorage;
_saveManager = saveManager;
_dataModelManager = dataModelManager;
_userModelManager = userModelManager;
_processModelManager = processModelManager;
}
/// <summary>
/// Get formdata as html
/// </summary>
/// <param name="formId"></param>
/// <param name="manager"></param>
/// <param name="dataModelManager"></param>
/// <returns></returns>
public static string GetFormHtml(string formId, IManager manager, IDataModelManager dataModelManager)
{
var html = File.ReadAllText(AppDomain.CurrentDomain.BaseDirectory + "HtmlTemplates/FormTemplate.html");
dataModelManager.GetDefaultDataModel(Enums.SQLOperation.SELECT, "FormItem");
dataModelManager.AddResultSet(new List <string> {
"Id", "ItemId", "ItemText", "IsGroup", "SequenceNumber"
});
dataModelManager.AddFilter("FormId", Enums.ParameterType._int, formId, Enums.CompareOperator.equal, Enums.LogicalOperator.none);
var formItems = manager.SelectData(dataModelManager.DataModel);
var list = formItems.AsEnumerable().ToList();
var groups = list.Where(x => Boolean.Parse(x["IsGroup"].ToString())).OrderBy(x => int.Parse(x["SequenceNumber"].ToString())).ToList();
var formData = string.Empty;
var sequenceNumber = 1;
foreach (var group in groups)
{
formData += "<h3 style=\"color:rgb(64,173,72);page-break-inside: avoid;\">" + group["ItemText"].ToString() + "</h3>";
var questions = list.Where(x => !string.IsNullOrEmpty(x["ItemId"].ToString())).Where(x => x["ItemId"].ToString() == group["Id"].ToString()).OrderBy(x => int.Parse(x["SequenceNumber"].ToString())).ToList();
foreach (var question in questions)
{
var seqNumber = string.Empty;
if (Boolean.Parse(question["IsGroup"].ToString()) == false)
{
seqNumber = sequenceNumber + ". ";
}
formData += "<p style=\"margin-left:20px;page-break-inside: avoid;\">" + seqNumber + question["ItemText"].ToString() + " </p>";
sequenceNumber++;
}
}
html = html.Replace("#FormData#", formData);
return(html);
}
/// <summary>
/// Get responsible all details with Id
/// </summary>
/// <param name="manager"></param>
/// <param name="dataModelManager"></param>
/// <returns></returns>
public static DataTable GetResponsibleFullDetails(IManager manager, IDataModelManager dataModelManager, string samAccountName = "")
{
if (string.IsNullOrEmpty(samAccountName))
{
var claim = ((ClaimsIdentity)Thread.CurrentPrincipal.Identity).FindFirst(ClaimTypes.Email);
var userName = claim?.Value;
if (userName == null)
{
claim = ((ClaimsIdentity)Thread.CurrentPrincipal.Identity).FindFirst(ClaimTypes.Upn);
}
samAccountName = claim?.Value;
}
dataModelManager.GetDefaultDataModel(Enums.SQLOperation.SELECT, "UserDetail");
dataModelManager.AddResultSet(new List <string> {
"Id", "SamAccountName", "Name", "Title", "Department", "ManagerId", "IsManager"
});
dataModelManager.AddFilter("SamAccountName", Enums.ParameterType._string, samAccountName, Enums.CompareOperator.equal, Enums.LogicalOperator.none);
var data = manager.SelectData(dataModelManager.DataModel);
return(data);
}
/// <summary>
/// Get Form Data
/// </summary>
/// <param name="formId"></param>
/// <param name="manager"></param>
/// <param name="dataModelManager"></param>
/// <returns></returns>
public static byte[] GetFormData(string formId, IManager manager, IDataModelManager dataModelManager)
{
byte[] data = { };
using (MemoryStream ms = new MemoryStream())
{
var html = GetFormHtml(formId, manager, dataModelManager);
MyFontResolverPdfSharp.Apply();
var config = new PdfGenerateConfig()
{
MarginBottom = 70,
MarginLeft = 20,
MarginRight = 20,
MarginTop = 70,
};
var pdf = PdfGenerator.GeneratePdf(html, PageSize.A4);
pdf.Save(ms);
data = ms.ToArray();
}
return(data);
}
/// <summary>
/// Add a journal note to the history table
/// </summary>
/// <param name="instanceId"></param>
/// <param name="eventId"></param>
/// <param name="documentId"></param>
/// <param name="type"></param>
/// <param name="title"></param>
/// <param name="eventDate"></param>
/// <param name="isLocked"></param>
public static void AddJournalHistory(string instanceId, string eventId, string documentId, string type, string title, DateTime eventDateTime, IManager manager, IDataModelManager dataModelManager)
{
if (!string.IsNullOrEmpty(instanceId))
{
dataModelManager.GetDefaultDataModel(Enums.SQLOperation.INSERT, DBEntityNames.Tables.JournalHistory.ToString());
dataModelManager.AddParameter(DBEntityNames.JournalHistory.InstanceId.ToString(), Enums.ParameterType._int, instanceId.ToString());
if (eventId != null)
{
dataModelManager.AddParameter(DBEntityNames.JournalHistory.EventId.ToString(), Enums.ParameterType._int, eventId.ToString());
}
if (documentId != null)
{
dataModelManager.AddParameter(DBEntityNames.JournalHistory.DocumentId.ToString(), Enums.ParameterType._int, documentId.ToString());
}
dataModelManager.AddParameter(DBEntityNames.JournalHistory.Type.ToString(), Enums.ParameterType._string, type);
dataModelManager.AddParameter(DBEntityNames.JournalHistory.Title.ToString(), Enums.ParameterType._string, title);
dataModelManager.AddParameter(DBEntityNames.JournalHistory.EventDate.ToString(), Enums.ParameterType._datetime, eventDateTime.ToString());
dataModelManager.AddParameter(DBEntityNames.JournalHistory.CreationDate.ToString(), Enums.ParameterType._datetime, DateTime.Now.ToString());
dataModelManager.AddParameter(DBEntityNames.JournalHistory.IsLocked.ToString(), Enums.ParameterType._boolean, "False");
manager.InsertData(dataModelManager.DataModel);
}
}
/// <summary>
/// Update simulation Id in instance table
/// </summary>
/// <param name="simulationId"></param>
public static void UpdateInstance(string instanceId, string simulationId, string xml, IManager manager, IDataModelManager dataModelManager)
{
dataModelManager.GetDefaultDataModel(Enums.SQLOperation.UPDATE, "Instance");
dataModelManager.AddParameter("SimulationId", Enums.ParameterType._int, simulationId);
dataModelManager.AddFilter("Id", Enums.ParameterType._int, instanceId, Enums.CompareOperator.equal, Enums.LogicalOperator.none);
if (!string.IsNullOrEmpty(xml))
{
dataModelManager.AddParameter("DCRXML", Enums.ParameterType._xml, xml);
}
manager.UpdateData(dataModelManager.DataModel);
}
/// <summary>
/// Get paramters from Event Type data
/// </summary>
/// <param name="eventTypeData"></param>
/// <param name="instanceId"></param>
/// <param name="manager"></param>
/// <returns></returns>
public static Dictionary <string, dynamic> GetParametersFromEventTypeData(string eventTypeData, string instanceId, IManager manager, IDataModelManager dataModelManager)
{
var data = "<data>" + eventTypeData + "</data>";
XmlDocument xml = new XmlDocument();
xml.LoadXml(data);
XmlNodeList resources = xml.SelectNodes("data/parameter");
var dictionary = new Dictionary <string, dynamic>();
foreach (XmlNode node in resources)
{
var key = node.Attributes["title"].Value;
dynamic value = node.Attributes["value"].Value;
value = ReplaceEventTypeKeyValues(value, instanceId, manager, dataModelManager);
dictionary.Add(key.ToLower(), value);
}
return(dictionary);
}
/// <summary>
/// Replace event type keys with actual values
/// </summary>
/// <param name="value"></param>
/// <param name="instanceId"></param>
/// <param name="manager"></param>
/// <param name="dataModelManager"></param>
/// <returns></returns>
public static dynamic ReplaceEventTypeKeyValues(string value, string instanceId, IManager manager, IDataModelManager dataModelManager)
{
var instanceTitle = string.Empty;
var caseForeignNo = string.Empty;
var internalCaseId = string.Empty;
dynamic returVal = value;
// make a one time call to database for case title and case foreign number
if ((value.Contains("$(Title)") || value.Contains("$(CaseNoForeign)") || value.Contains("$(InternalCaseId)")) && (string.IsNullOrEmpty(instanceTitle) && string.IsNullOrEmpty(caseForeignNo) && string.IsNullOrEmpty(internalCaseId)))
{
dataModelManager.GetDefaultDataModel(Enums.SQLOperation.SELECT, "Instance");
dataModelManager.AddResultSet(new List <string>()
{
"Title", "CaseNoForeign", "InternalCaseID"
});
dataModelManager.AddFilter("Id", Enums.ParameterType._int, instanceId, Enums.CompareOperator.equal, Enums.LogicalOperator.none);
var instanceDetails = manager.SelectData(dataModelManager.DataModel);
instanceTitle = instanceDetails.Rows[0]["Title"].ToString();
caseForeignNo = instanceDetails.Rows[0]["CaseNoForeign"].ToString();
internalCaseId = instanceDetails.Rows[0]["InternalCaseID"].ToString();
}
if (value.Contains("$(Title)") && !string.IsNullOrEmpty(instanceTitle))
{
returVal = value.Replace("$(Title)", instanceTitle);
}
else if (value.Contains("$(CaseNoForeign)") && !string.IsNullOrEmpty(caseForeignNo))
{
returVal = value.Replace("$(CaseNoForeign)", caseForeignNo);
}
else if (value.Contains("$(InternalCaseId)") && !string.IsNullOrEmpty(internalCaseId))
{
returVal = value.Replace("$(InternalCaseId)", internalCaseId);
}
else if (value.Contains("$(employee."))
{
var occurences = value.Occurences("$(employee.");
while (value.Contains("$(employee.") && occurences > 0)
{
var startIndexColumnKey = value.IndexOf("$(employee.");
var endIndexColumnKey = -1;
foreach (var key in value)
{
endIndexColumnKey++;
if (key == ')')
{
break;
}
}
var keyToReplace = value.Substring(startIndexColumnKey, (endIndexColumnKey + 1) - startIndexColumnKey);
var startIndexColumnName = keyToReplace.IndexOf(".");
startIndexColumnName++;
var endIndexColumnName = -1;
foreach (var key in keyToReplace)
{
endIndexColumnName++;
if (key == ')')
{
break;
}
}
var columnName = keyToReplace.Substring(startIndexColumnName, endIndexColumnName - startIndexColumnName);
var columnValue = ReplaceValueWithEmployeeData(columnName, instanceId, manager, dataModelManager);
if (!string.IsNullOrEmpty(columnValue))
{
value = value.Replace(keyToReplace, columnValue);
}
occurences--;
}
returVal = value;
}
else if (value.Contains("$(loggedInUser)"))
{
returVal = value.Replace("$(loggedInUser)", GetCurrentUserName());
}
else if (value.Equals("$(now)"))
{
returVal = DateTime.Now;
}
else if (value.Contains("$(now)"))
{
returVal = value.Replace("$(now)", DateTime.Now.ToString());
}
return(returVal);
}
public FileController(IManager manager, IDataModelManager dataModelManager)
{
_manager = manager;
_dataModelManager = dataModelManager;
}
/// <summary>
/// Add Document
/// </summary>
/// <param name="instanceId"></param>
/// <param name="fileType"></param>
/// <param name="givenFileName"></param>
/// <param name="fileName"></param>
/// <param name="eventId"></param>
/// <param name="manager"></param>
/// <param name="dataModelManager"></param>
/// <returns></returns>
public string AddDocument(string instanceId, string fileType, string givenFileName, string fileName, string eventId, IManager manager, IDataModelManager dataModelManager)
{
string ext = Path.GetExtension(fileName);
string fileLink = DateTime.Now.ToFileTime() + ext;
string filePath = string.Empty;
switch (fileType)
{
case "Personal":
DirectoryInfo directoryInfo = new DirectoryInfo(Configurations.Config.PersonalFileLocation);
if (!directoryInfo.Exists)
{
directoryInfo.Create();
}
string currentUser = Common.GetCurrentUserName();
directoryInfo = new DirectoryInfo(Configurations.Config.PersonalFileLocation + "\\" + currentUser);
if (!directoryInfo.Exists)
{
directoryInfo.Create();
}
filePath = directoryInfo.FullName;
break;
case "Instance":
directoryInfo = new DirectoryInfo(Configurations.Config.InstanceFileLocation);
if (!directoryInfo.Exists)
{
directoryInfo.Create();
}
directoryInfo = new DirectoryInfo(Configurations.Config.InstanceFileLocation + "\\" + instanceId);
if (!directoryInfo.Exists)
{
directoryInfo.Create();
}
filePath = directoryInfo.FullName;
break;
case "Temp":
default:
directoryInfo = new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory + "\\tmp\\" + DateTime.Now.ToFileTime());
if (!directoryInfo.Exists)
{
directoryInfo.Create();
}
filePath = directoryInfo.FullName;
try
{
fileLink = fileName;
givenFileName = eventId;
}
catch (Exception)
{
}
break;
}
filePath = filePath + "\\" + fileLink;
if (fileType == "Temp")
{
fileLink = filePath;
}
Common.AddDocument(givenFileName, fileType, fileLink, instanceId, manager, dataModelManager);
return(filePath);
}
public Tuple <string, string> AddDocument(string instanceId, string fileType, string givenFileName, string fileName, string eventId, bool isDraft, DateTime eventDateTime, IManager manager, IDataModelManager dataModelManager)
{
CreateFileLink(fileName);
string filePath = AddDocumentChecks(instanceId, fileType, givenFileName, fileName, eventId);
string documentId = Common.AddDocument(givenFileName, fileType, fileLink, instanceId, isDraft, eventDateTime, manager, dataModelManager);
Tuple <string, string> returnTuple = new Tuple <string, string>(filePath, documentId);
return(returnTuple);
}
/// <summary>
/// Add Document
/// </summary>
/// <param name="instanceId"></param>
/// <param name="fileType"></param>
/// <param name="givenFileName"></param>
/// <param name="fileName"></param>
/// <param name="eventId"></param>
/// <param name="manager"></param>
/// <param name="dataModelManager"></param>
/// <returns></returns>
public string AddDocument(string instanceId, string fileType, string givenFileName, string fileName, string eventId, IManager manager, IDataModelManager dataModelManager)
{
CreateFileLink(fileName);
string filePath = AddDocumentChecks(instanceId, fileType, givenFileName, fileName, eventId);
Common.AddDocument(givenFileName, fileType, fileLink, instanceId, false, DateTime.Now, manager, dataModelManager);
return(filePath);
}
/// <summary>
/// Save parameters
/// </summary>
/// <param name="parameters"></param>
private static void SaveEventTypeDataParamertes(string instanceId, string parametersXML, string method, Exception ex, IManager manager, IDataModelManager dataModelManager)
{
dataModelManager.GetDefaultDataModel(Enums.SQLOperation.INSERT, DBEntityNames.Tables.AcadreLog.ToString());
dataModelManager.AddParameter(DBEntityNames.AcadreLog.Method.ToString(), Enums.ParameterType._string, method);
dataModelManager.AddParameter(DBEntityNames.AcadreLog.Parameters.ToString(), Enums.ParameterType._xml, parametersXML);
dataModelManager.AddParameter(DBEntityNames.AcadreLog.IsSuccess.ToString(), Enums.ParameterType._boolean, bool.FalseString);
dataModelManager.AddParameter(DBEntityNames.AcadreLog.ErrorStatement.ToString(), Enums.ParameterType._string, ex.Message);
dataModelManager.AddParameter(DBEntityNames.AcadreLog.ErrorStackTrace.ToString(), Enums.ParameterType._string, ex.StackTrace);
dataModelManager.AddParameter(DBEntityNames.AcadreLog.InstanceId.ToString(), Enums.ParameterType._string, instanceId);
manager.InsertData(dataModelManager.DataModel);
}
/// <summary>
/// Create Document in Acadre
/// </summary>
/// <param name="fileInfo"></param>
/// <param name="fileBytes"></param>
/// <returns></returns>
public static string CreateDocument(Dictionary <string, dynamic> parameters, string fileName, byte[] fileBytes, string instanceId, IManager manager, IDataModelManager dataModelManager)
{
try
{
string documentCategoryCode = parameters["DocumentCategoryCode".ToLower()];
string documentTitleText = parameters["DocumentTitleText".ToLower()];
string documentStatusCode = parameters["DocumentStatusCode".ToLower()];
DateTime documentDate = parameters["DocumentDate".ToLower()];
string documentAccessCode = parameters["DocumentAccessCode".ToLower()];
string documentCaseId = parameters["DocumentCaseId".ToLower()];
string documentDescriptionText = parameters["DocumentDescriptionText".ToLower()];
string documentAccessLevel = parameters["DocumentAccessLevel".ToLower()];
string documentTypeCode = parameters["DocumentTypeCode".ToLower()];
string recordStatusCode = parameters["RecordStatusCode".ToLower()];
bool documentEvenOutRequired = bool.Parse(parameters["DocumentEvenOutRequired".ToLower()].ToString().ToLower());
string documentUserId = parameters["DocumentUserId".ToLower()];
string recordPublicationIndicator = parameters["PublicationIndicator".ToLower()];
// set user
CaseManagement.ActingFor(GetCurrentUserName());
var documentId = CaseManagement.CreateDocumentService(
documentCaseId,
recordStatusCode,
documentTypeCode,
documentDescriptionText,
documentAccessCode,
documentStatusCode,
documentTitleText,
documentCategoryCode,
recordPublicationIndicator,
fileName,
fileBytes
);
return(documentId);
}
catch (Exception ex)
{
var parametersXML = GetParametersXML(parameters);
SaveEventTypeDataParamertes(instanceId, parametersXML, "CreateDocument", ex, manager, dataModelManager);
throw ex;
}
}
/// <summary>
/// Create Case in Acadre
/// </summary>
/// <param name="parameters"></param>
/// <param name="responsible"></param>
/// <returns></returns>
public static string CreateCase(string instanceId, Dictionary <string, dynamic> parameters, IManager manager, IDataModelManager dataModelManager)
{
try
{
// get parameters
var personNameForAddressingName = parameters["personNameForAddressingName".ToLower()];
var personCivilRegistrationNumber = parameters["PersonCivilRegistrationIdentifier".ToLower()];
var caseFileTypeCode = parameters["caseFileTypeCode".ToLower()];
var accessCode = parameters["accessCode".ToLower()];
var caseFileTitleText = parameters["caseFileTitleText".ToLower()];
var journalizingCode = parameters["journalizingCode".ToLower()];
var facet = parameters["facet".ToLower()];
var caseResponsible = parameters["CaseResponsible".ToLower()];
var administrativeUnit = parameters["administrativeUnit".ToLower()];
var caseContent = parameters["caseContent".ToLower()];
var caseFileDisposalCode = parameters["caseFileDisposalCode".ToLower()];
var deletionCode = parameters["deletionCode".ToLower()];
var caseRestrictedFromPublicText = parameters["RestrictedFromPublicText".ToLower()];
// set user
CaseManagement.ActingFor(GetCurrentUserName());
// create case in acadre
var caseId = CaseManagement.CreateCase(
personNameForAddressingName,
personCivilRegistrationNumber,
caseFileTypeCode,
accessCode,
caseFileTitleText,
journalizingCode,
facet,
caseResponsible,
administrativeUnit,
caseContent,
caseFileDisposalCode,
deletionCode,
caseRestrictedFromPublicText);
return(caseId);
}
catch (Exception ex)
{
var parametersXML = GetParametersXML(parameters);
SaveEventTypeDataParamertes(instanceId, parametersXML, "CreateCase", ex, manager, dataModelManager);
throw ex;
}
}
/// <summary>
/// Sync Events
/// </summary>
/// <param name="instanceId"></param>
/// <param name="xml"></param>
/// <param name="responsibleId"></param>
public static void SyncEvents(string instanceId, string xml, string responsibleId, IManager manager, IDataModelManager dataModelManager)
{
dataModelManager.GetDefaultDataModel(Enums.SQLOperation.SP, "SyncEvents");
dataModelManager.AddParameter("InstanceId", Enums.ParameterType._int, instanceId);
dataModelManager.AddParameter("EventXML", Enums.ParameterType._xml, xml);
dataModelManager.AddParameter("LoginUser", Enums.ParameterType._int, responsibleId);
manager.ExecuteStoreProcedure(dataModelManager.DataModel);
}
/// <summary>
/// Add a document
/// </summary>
/// <param name="documentName"></param>
/// <param name="type"></param>
/// <param name="link"></param>
public static string AddDocument(string documentName, string type, string link, string instanceId, bool isDraft, DateTime eventDateTime, IManager manager, IDataModelManager dataModelManager)
{
dataModelManager.GetDefaultDataModel(Enums.SQLOperation.INSERT, DBEntityNames.Tables.Document.ToString());
dataModelManager.AddParameter(DBEntityNames.Document.Title.ToString(), Enums.ParameterType._string, documentName);
dataModelManager.AddParameter(DBEntityNames.Document.Type.ToString(), Enums.ParameterType._string, type);
dataModelManager.AddParameter(DBEntityNames.Document.Link.ToString(), Enums.ParameterType._string, link);
dataModelManager.AddParameter(DBEntityNames.Document.Responsible.ToString(), Enums.ParameterType._string, "$(loggedInUser)");
dataModelManager.AddParameter(DBEntityNames.Document.UploadDate.ToString(), Enums.ParameterType._datetime, DateTime.Now.ToString());
dataModelManager.AddParameter(DBEntityNames.Document.IsLocked.ToString(), Enums.ParameterType._boolean, "false");
dataModelManager.AddParameter(DBEntityNames.Document.IsDraft.ToString(), Enums.ParameterType._boolean, isDraft.ToString());
if (!string.IsNullOrEmpty(instanceId))
{
dataModelManager.AddParameter(DBEntityNames.Document.InstanceId.ToString(), Enums.ParameterType._int, instanceId);
}
var dataTable = manager.InsertData(dataModelManager.DataModel);
var documentId = dataTable.Rows[0].ItemArray[0].ToString();
AddJournalHistory(instanceId, null, documentId, type, documentName, eventDateTime, manager, dataModelManager);
return(documentId);
}
/// <summary>
/// Add a document
/// </summary>
/// <param name="documentName"></param>
/// <param name="type"></param>
/// <param name="link"></param>
public static void AddDocument(string documentName, string type, string link, string instanceId, IManager manager, IDataModelManager dataModelManager)
{
dataModelManager.GetDefaultDataModel(Enums.SQLOperation.INSERT, DBEntityNames.Tables.Document.ToString());
dataModelManager.AddParameter(DBEntityNames.Document.Title.ToString(), Enums.ParameterType._string, documentName);
dataModelManager.AddParameter(DBEntityNames.Document.Type.ToString(), Enums.ParameterType._string, type);
dataModelManager.AddParameter(DBEntityNames.Document.Link.ToString(), Enums.ParameterType._string, link);
dataModelManager.AddParameter(DBEntityNames.Document.Responsible.ToString(), Enums.ParameterType._string, "$(loggedInUser)");
if (!string.IsNullOrEmpty(instanceId))
{
dataModelManager.AddParameter(DBEntityNames.Document.InstanceId.ToString(), Enums.ParameterType._int, instanceId);
}
manager.InsertData(dataModelManager.DataModel);
}
/// <summary>
/// Replace key values with actual employee values
/// </summary>
/// <param name="value"></param>
private static string ReplaceValueWithEmployeeData(string columnName, string instanceId, IManager manager, IDataModelManager dataModelManager)
{
// get selected employee sam account name
dataModelManager.GetDefaultDataModel(Enums.SQLOperation.SELECT, DBEntityNames.Tables.InstanceExtension.ToString());
dataModelManager.AddResultSet(new List <string>()
{
DBEntityNames.InstanceExtension.Employee.ToString()
});
dataModelManager.AddFilter(DBEntityNames.InstanceExtension.InstanceId.ToString(), Enums.ParameterType._string, instanceId, Enums.CompareOperator.equal, Enums.LogicalOperator.none);
var employeeId = manager.SelectData(dataModelManager.DataModel);
if (employeeId.Rows.Count > 0)
{
var viewName = Configurations.Config.EmployeeView;
// sql query
dataModelManager.GetDefaultDataModel(Enums.SQLOperation.SELECT, viewName);
dataModelManager.AddResultSet(new List <string>()
{
columnName
});
dataModelManager.AddFilter("EmployeeId", Enums.ParameterType._string, employeeId.Rows[0][DBEntityNames.InstanceExtension.Employee.ToString()].ToString(), Enums.CompareOperator.equal, Enums.LogicalOperator.none);
try
{
var columnValue = manager.SelectData(dataModelManager.DataModel);
return(columnValue.Rows[0][columnName].ToString());
}
catch (Exception ex)
{
Logger logger = LogManager.GetCurrentClassLogger();
logger.Error(ex, "Error");
}
}
return(string.Empty);
}
