public SqlServerEntityBatchUpdate(AbstractConnection connection, Entity entity)
: base(connection) {
_connection = connection;
_entity = entity;
BatchSize = connection.BatchSize;
UseTransaction = true;
}
public bool Exists(AbstractConnection connection, Entity entity) {
if (!new DirectoryInfo(LuceneDirectoryFactory.Path(connection, entity)).Exists)
return false;
using (var dir = LuceneDirectoryFactory.Create(connection, entity)) {
return dir.ListAll().Length > 0;
}
}
public override void WriteEndVersion(Process process, AbstractConnection input, Entity entity, bool force = false) {
if (entity.Updates + entity.Inserts > 0 || force) {
var client = new ElasticSearchClientFactory().Create(this, TflBatchEntity(entity.ProcessName));
var versionType = entity.Version == null ? "string" : entity.Version.SimpleType;
string end;
if (versionType.Equals("datetime") && entity.End is DateTime) {
end = ((DateTime)entity.End).ToString("yyyy-MM-ddTHH:mm:ss.fff");
} else if (versionType.Equals("byte[]") || versionType.Equals("rowversion")) {
end = Common.BytesToHexString((byte[])entity.End);
} else {
end = new DefaultFactory(Logger).Convert(entity.End, versionType).ToString();
}
var body = new {
id = entity.TflBatchId,
tflbatchid = entity.TflBatchId,
process = entity.ProcessName,
connection = input.Name,
entity = entity.Alias,
updates = entity.Updates,
inserts = entity.Inserts,
deletes = entity.Deletes,
version = end,
version_type = versionType,
tflupdate = DateTime.UtcNow
};
client.Client.Index(client.Index, client.Type, body);
}
}
public VistaSystemFileHandler(AbstractConnection cxn)
{
myCxn = cxn;
getFileDefs();
files = new Hashtable();
lookupTables = new Hashtable();
}
public override void WriteEndVersion(Process process, AbstractConnection input, Entity entity, bool force = false) {
if (entity.Updates + entity.Inserts > 0 || force) {
var solr = GetOperations(process, entity.OutputName());
var versionType = entity.Version == null ? "string" : entity.Version.SimpleType;
string end;
if (versionType.Equals("datetime") && entity.End is DateTime) {
end = ((DateTime)entity.End).ToString("yyyy-MM-ddTHH:mm:ss.fff");
} else if (versionType.Equals("byte[]") || versionType.Equals("rowversion")) {
end = Common.BytesToHexString((byte[])entity.End);
} else {
end = new DefaultFactory(Logger).Convert(entity.End, versionType).ToString();
}
var doc = new Dictionary<string, object> {
{ "id", entity.TflBatchId},
{ "tflbatchid", entity.TflBatchId},
{ "process", entity.ProcessName},
{ "connection", input.Name},
{ "entity", entity.Alias},
{ "updates", entity.Updates},
{ "inserts", entity.Inserts},
{ "deletes", entity.Deletes},
{ "version", end},
{ "version_type", versionType},
{ "tflupdate", DateTime.UtcNow}
};
solr.Add(doc);
solr.Commit();
}
}
public bool Exists(AbstractConnection connection, Entity entity) {
using (var cn = connection.GetConnection()) {
cn.Open();
var table = cn.Query<string>(SQL, new { name = entity.OutputName() }).DefaultIfEmpty(string.Empty).FirstOrDefault();
return !string.IsNullOrEmpty(table);
}
}
public override void WriteEndVersion(Process process, AbstractConnection input, Entity entity, bool force = false) {
if (entity.Updates + entity.Inserts <= 0 && !force)
return;
var versionType = entity.Version == null ? "string" : entity.Version.SimpleType;
var end = entity.End ?? new DefaultFactory(Logger).Convert(entity.End, versionType);
using (var dir = LuceneDirectoryFactory.Create(this, TflBatchEntity(entity.ProcessName))) {
using (var writer = new IndexWriter(dir, new KeywordAnalyzer(), IndexWriter.MaxFieldLength.UNLIMITED)) {
var doc = new Document();
doc.fields.Add(new NumericField("id", Libs.Lucene.Net.Document.Field.Store.YES, true).SetIntValue(entity.TflBatchId));
doc.fields.Add(new Libs.Lucene.Net.Document.Field("process", entity.ProcessName, Libs.Lucene.Net.Document.Field.Store.YES, Libs.Lucene.Net.Document.Field.Index.NOT_ANALYZED_NO_NORMS));
doc.fields.Add(new Libs.Lucene.Net.Document.Field("connection", input.Name, Libs.Lucene.Net.Document.Field.Store.YES, Libs.Lucene.Net.Document.Field.Index.NOT_ANALYZED_NO_NORMS));
doc.fields.Add(new Libs.Lucene.Net.Document.Field("entity", entity.Alias, Libs.Lucene.Net.Document.Field.Store.YES, Libs.Lucene.Net.Document.Field.Index.NOT_ANALYZED_NO_NORMS));
doc.fields.Add(new NumericField("updates", Libs.Lucene.Net.Document.Field.Store.YES, true).SetLongValue(entity.Updates));
doc.fields.Add(new NumericField("inserts", Libs.Lucene.Net.Document.Field.Store.YES, true).SetLongValue(entity.Inserts));
doc.fields.Add(new NumericField("deletes", Libs.Lucene.Net.Document.Field.Store.YES, true).SetLongValue(entity.Deletes));
doc.fields.Add(LuceneWriter.CreateField("version", versionType, new SearchType { Analyzer = "keyword" }, end));
doc.fields.Add(new Libs.Lucene.Net.Document.Field("version_type", versionType, Libs.Lucene.Net.Document.Field.Store.YES, Libs.Lucene.Net.Document.Field.Index.NOT_ANALYZED_NO_NORMS));
doc.fields.Add(new NumericField("tflupdate", Libs.Lucene.Net.Document.Field.Store.YES, true).SetLongValue(DateTime.UtcNow.Ticks));
writer.AddDocument(doc);
writer.Commit();
writer.Optimize();
}
}
}
public static FSDirectory Create(AbstractConnection connection, Entity entity) {
var directoryInfo = new DirectoryInfo(Path(connection, entity));
if (!directoryInfo.Exists) {
directoryInfo.Create();
}
return FSDirectory.Open(directoryInfo);
}
public bool Check(AbstractConnection connection) {
var result = connection.Name.Equals("output", IC) || new DirectoryInfo(connection.Folder).Exists;
if (!result) {
_logger.Warn("Could not verify that '{0}' exists.", connection.Folder);
}
return result;
}
public static FSDirectory Create(AbstractConnection connection) {
var directoryInfo = new DirectoryInfo(connection.Folder);
if (!directoryInfo.Exists) {
directoryInfo.Create();
}
return FSDirectory.Open(directoryInfo);
}
public SqlEntityDelete(AbstractConnection connection, Entity entity)
: base(connection) {
_name = Connection.Enclose(entity.OutputName());
_isMaster = entity.IsMaster();
BatchSize = connection.BatchSize;
UseTransaction = true;
}
public Fields Read(AbstractConnection connection, string process, string prefix, string name, string schema, bool isMaster = false) {
var fields = new Fields();
using (var cn = connection.GetConnection()) {
cn.Open();
var sql = PrepareSql();
connection.Logger.EntityDebug(name, sql);
var results = cn.Query(sql, new { name, schema });
foreach (var result in results) {
var columnName = result.COLUMN_NAME;
var type = GetSystemType(result.DATA_TYPE);
var length = result.CHARACTER_MAXIMUM_LENGTH == "0" || result.CHARACTER_MAXIMUM_LENGTH == "-1" ? "64" : result.CHARACTER_MAXIMUM_LENGTH;
var fieldType = (bool)result.IS_PRIMARY_KEY ? (isMaster ? FieldType.MasterKey : FieldType.PrimaryKey) : FieldType.NonKey;
var field = new Field(type, length, fieldType, true, string.Empty) {
Name = columnName,
Entity = name,
Process = process,
Index = Convert.ToInt16(result.ORDINAL_POSITION - 1),
Schema = schema,
Input = true,
Precision = result.NUMERIC_PRECISION,
Scale = result.NUMERIC_SCALE,
Alias = prefix + columnName
};
fields.Add(field);
}
}
return fields;
}
public IScriptReponse Execute(AbstractConnection connection, string script, int timeOut = 0) {
var response = new ScriptResponse();
var server = new Server();
var logger = connection.Logger;
try {
logger.Debug("Connecting to {0} on {1}.", connection.Database, connection.Server);
server.Connect(connection.GetConnectionString());
var results = server.Execute(script);
foreach (XmlaResult result in results) {
foreach (XmlaMessage message in result.Messages) {
response.Messages.Add(message.Description);
}
}
response.Success = response.Messages.Count == 0;
} catch (Exception e) {
logger.Debug(e.Message + (e.InnerException != null ? " " + e.InnerException.Message : string.Empty));
response.Messages.Add(e.Message);
} finally {
if (server.Connected) {
logger.Debug("Disconnecting from {0} on {1}.", connection.Database, connection.Server);
server.Disconnect();
}
}
return response;
}
public SqlOverrideOperation(Entity entity, AbstractConnection connection)
: base(connection) {
CommandBehavior = CommandBehavior.Default;
EntityName = entity.Name;
_entity = entity;
_fields = entity.Fields.WithInput().NameAliases().ToArray();
}
public ElasticSearchEntityExtract(AbstractConnection connection, Entity entity, IEnumerable<string> fields, bool correspondingKeys = false) {
_entity = entity;
_correspondingKeys = correspondingKeys;
_fields = fields.Select(a => a.ToLower()).ToArray(); //for now
_client = new ElasticSearchClientFactory().CreateNest(connection, entity);
Name = string.Format("ElasticsearchEntityExtract ({0}:{1})", _client.Index, _client.Type);
}
public SqlKeysOverrideOperation(Entity entity, AbstractConnection connection)
: base(connection) {
_entity = entity;
EntityName = entity.Name;
_fields = entity.PrimaryKey.Aliases().ToArray();
_length = _fields.Length;
}
public SqlServerEntityKeysExtractFromOutput(AbstractConnection connection, Entity entity)
: base(connection) {
_connection = connection;
EntityName = entity.Name;
_entity = entity;
_fields = new List<string>(new FieldSqlWriter(entity.PrimaryKey).AddDeleted(entity).Alias(connection.L, connection.R).Keys()) { "TflKey" };
_key = _entity.PrimaryKey;
}
public SolrEntityOutputKeysExtract(AbstractConnection connection, Entity entity) {
_entity = entity;
_aliasTypes = _entity.PrimaryKey.AliasTypes().ToList();
if (_entity.Version != null) {
_aliasTypes.Add(new AliasType() { Alias = _entity.Version.Alias, AliasLower = _entity.Version.Alias.ToLower(), SimpleType = _entity.Version.SimpleType });
}
_sourceInclude = _aliasTypes.Select(at => at.AliasLower).ToArray();
}
public SqlEntityKeysExtractAllFromOutput(AbstractConnection connection, Entity entity)
: base(connection) {
_entity = entity;
EntityName = entity.Name;
_keys = _entity.Delete && _entity.IsMaster() ?
new List<string>(entity.PrimaryKey.Aliases()) { "TflDeleted", "TflKey" } :
new List<string>(entity.PrimaryKey.Aliases()) { "TflKey" };
}
public bool Check(AbstractConnection connection) {
var fileInfo = new FileInfo(connection.File);
if (!fileInfo.Exists) {
_logger.Warn("File {0} does not exist. Creating it.", fileInfo.Name);
System.IO.File.Create(fileInfo.FullName).Dispose();
}
return true;
}
public ElasticSearchEntityOutputKeysExtract(AbstractConnection connection, Entity entity) {
_aliasTypes = entity.PrimaryKey.AliasTypes().ToList();
if (entity.Version != null) {
_aliasTypes.Add(new AliasType() { Alias = entity.Version.Alias, AliasLower = entity.Version.Alias.ToLower(), SimpleType = entity.Version.SimpleType });
}
_sourceInclude = _aliasTypes.Select(at => at.AliasLower).ToArray();
_client = new ElasticSearchClientFactory().Create(connection, entity);
}
public bool RecordsExist(AbstractConnection connection, Entity entity) {
var checker = new SolrConnectionChecker(connection.Logger);
if (checker.Check(connection)) {
throw new NotImplementedException();
}
return false;
}
internal DdrLister buildGetSubrecordsQuery(AbstractConnection cxn, string ien)
{
DdrLister query = new DdrLister(cxn);
query.File = FILE_NUMBER;
query.Iens = ',' + ien + ',';
query.Fields = ".01;.02;.03;.04";
query.Flags = "IP";
query.Xref = "#";
return query;
}
private static void Execute(AbstractConnection connection, string sqlFormat, params object[] values) {
var sql = values.Length > 0 ? string.Format(sqlFormat, values) : sqlFormat;
using (var cn = connection.GetConnection()) {
cn.Open();
var cmd = cn.CreateCommand();
cmd.CommandText = sql;
cmd.CommandType = CommandType.Text;
cmd.ExecuteNonQuery();
}
}
public void Drop(AbstractConnection connection, Entity entity) {
if (!EntityExists.Exists(connection, entity))
return;
var client = new ElasticSearchClientFactory().Create(connection, entity);
var response = client.Client.IndicesDelete(client.Index);
if (response.Success)
return;
connection.Logger.EntityWarn(entity.Name, response.ServerError.Error);
connection.Logger.EntityWarn(entity.Name, "Trouble deleting {0} {1}.", client.Index, client.Type);
}
public SqlServerBulkLoadOperation(AbstractConnection connection, Entity entity)
: base(connection, connection.Enclose(entity.OutputName())) {
_entity = entity;
_batchSize = connection.BatchSize;
UseTransaction = false;
TurnOptionOn(SqlBulkCopyOptions.TableLock);
TurnOptionOn(SqlBulkCopyOptions.UseInternalTransaction);
TurnOptionOff(SqlBulkCopyOptions.CheckConstraints);
TurnOptionOff(SqlBulkCopyOptions.FireTriggers);
TurnOptionOn(SqlBulkCopyOptions.KeepNulls);
}
public SolrLoadOperation(Entity entity, AbstractConnection connection) {
_guids.AddRange(new Fields(entity.Fields, entity.CalculatedFields).WithOutput().WithGuid().Aliases());
_dates.AddRange(new Fields(entity.Fields, entity.CalculatedFields).WithOutput().WithDate().Aliases());
_singleKey = entity.PrimaryKey.Count == 1;
_solrMap = new SolrEntityCreator(Logger).GetFieldMap(entity);
_keys = entity.PrimaryKey.Aliases().ToArray();
_key = entity.FirstKey();
_batchSize = connection.BatchSize;
}
public bool Check(AbstractConnection connection) {
bool isReady;
var server = new Server();
try {
server.Connect(connection.GetConnectionString());
isReady = server.Connected;
server.Disconnect();
} catch (Exception e) {
_logger.Warn("Error checking {0} connection. {1}", connection.Name, e.Message);
return false;
}
return isReady;
}
public int Count(AbstractConnection connection, Entity entity, bool useAlias) {
if (_connectionChecker == null || _connectionChecker.Check(connection)) {
if (_entityExists.Exists(connection, entity)) {
using (var cn = connection.GetConnection()) {
cn.Open();
var sql = string.Format("SELECT COUNT(*) FROM [{0}].[{1}] WITH (NOLOCK);", entity.Schema, entity.OutputName());
var cmd = cn.CreateCommand();
cmd.CommandText = sql;
return (int)cmd.ExecuteScalar();
}
}
}
return 0;
}
public override void Create(AbstractConnection connection, Process process, Entity entity) {
if (EntityExists != null && EntityExists.Exists(connection, entity)) {
process.Logger.EntityWarn(entity.Name,"Trying to create entity that already exists! {0}", entity.Name);
return;
}
var keyType = entity.IsMaster() ? FieldType.MasterKey : FieldType.PrimaryKey;
var writer = process.StarEnabled && keyType == FieldType.MasterKey ?
new FieldSqlWriter(entity.Fields, entity.CalculatedFields, process.CalculatedFields, GetRelationshipFields(process.Relationships, entity)) :
new FieldSqlWriter(entity.Fields, entity.CalculatedFields);
var primaryKey = writer.FieldType(keyType).Alias(connection.L, connection.R).Asc().Values();
var defs = new List<string>();
defs.AddRange(writer
.Reload()
.AddBatchId(entity.Index)
.AddDeleted(entity)
.AddSurrogateKey(entity.Index)
.Output()
.Alias(connection.L, connection.R)
.DataType(new SqlServerDataTypeService())
.AppendIf(" NOT NULL", keyType)
.Values());
var rowVersion = entity.Fields.WithSimpleType("rowversion").WithoutInput().WithoutOutput();
if (rowVersion.Any()) {
var alias = rowVersion.First().Alias;
defs.Add(connection.Enclose(alias) + " [ROWVERSION] NOT NULL");
}
var createSql = connection.TableQueryWriter.CreateTable(entity.OutputName(), defs);
_logger.EntityDebug(entity.Name, createSql);
var indexSql = connection.TableQueryWriter.AddUniqueClusteredIndex(entity.OutputName());
_logger.EntityDebug(entity.Name, indexSql);
var keySql = connection.TableQueryWriter.AddPrimaryKey(entity.OutputName(), primaryKey);
_logger.EntityDebug(entity.Name, keySql);
using (var cn = connection.GetConnection()) {
cn.Open();
cn.Execute(createSql);
cn.Execute(indexSql);
cn.Execute(keySql);
_logger.EntityInfo(entity.Name, "Initialized {0} in {1} on {2}.", entity.OutputName(), connection.Database, connection.Server);
}
}
//private static NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
public void Read(AbstractConnection connection, AbstractTransaction transaction, UPrintDataSet dataSet)
{
adapter = new NpgsqlDataAdapter();
adapter.SelectCommand = new NpgsqlCommand(selection, connection.GetConnection(), transaction.GetTransaction());
adapter.Fill(dataSet, "job");
}
public override IConsultDao getConsultDao(AbstractConnection cxn)
{
return(new VistaConsultDao(cxn));
}
public string getLrDfn(AbstractConnection cxn, string pid)
{
return(((ILabsDao)cxn.getDao(DAO_NAME)).getLrDfn(pid));
}
public override IRadiologyDao getRadiologyDao(AbstractConnection cxn)
{
return(new VistaRadiologyDao(cxn));
}
public override IUserDao getUserDao(AbstractConnection cxn)
{
return(new VistaUserDao(cxn));
}
public override IEncounterDao getEncounterDao(AbstractConnection cxn)
{
return(new VistaEncounterDao(cxn));
}
public override IPharmacyDao getPharmacyDao(AbstractConnection cxn)
{
return(new VistaPharmacyDao(cxn));
}
public override IClaimsDao getClaimsDao(AbstractConnection cxn)
{
return(new AdrClaimsDao(cxn));
}
public override IRadiologyDao getRadiologyDao(AbstractConnection cxn)
{
return(null);
}
public override ILabsDao getLabsDao(AbstractConnection cxn)
{
return(new VistaLabsDao(cxn));
}
public static IndexSearcher Create(AbstractConnection connection, Entity entity)
{
return(new IndexSearcher(LuceneReaderFactory.Create(connection, entity, true)));
}
public VistaClaimsDao(AbstractConnection cxn)
{
this.cxn = cxn;
}
public override IRemindersDao getRemindersDao(AbstractConnection cxn)
{
return(new VistaRemindersDao(cxn));
}
public static OrderedDictionary getUsersWithOption(AbstractConnection cxn, string optionName)
{
return(getDao(cxn).getUsersWithOption(optionName));
}
public void Update(AbstractConnection connection, AbstractTransaction transaction, UPrintDataSet dataSet)
{
adapter = new NpgsqlDataAdapter();
//adapter.SelectCommand = new NpgsqlCommand(selection, connection.GetConnection(), transaction.GetTransaction());
//adapter.Fill(dataSet, "job");
adapter.InsertCommand = new NpgsqlCommand(insertion, connection.GetConnection(), transaction.GetTransaction());
adapter.InsertCommand.Parameters.Add(new NpgsqlParameter()
{
SourceColumn = "id", ParameterName = "@id"
});
adapter.InsertCommand.Parameters.Add(new NpgsqlParameter()
{
SourceColumn = "name", ParameterName = "@name"
});
adapter.InsertCommand.Parameters.Add(new NpgsqlParameter()
{
SourceColumn = "date_add", ParameterName = "@date_add"
});
adapter.InsertCommand.Parameters.Add(new NpgsqlParameter()
{
SourceColumn = "description", ParameterName = "@description"
});
adapter.InsertCommand.Parameters.Add(new NpgsqlParameter()
{
SourceColumn = "person", ParameterName = "@person"
});
adapter.InsertCommand.Parameters.Add(new NpgsqlParameter()
{
SourceColumn = "model", ParameterName = "@model"
});
adapter.UpdateCommand = new NpgsqlCommand(updation, connection.GetConnection(), transaction.GetTransaction());
adapter.UpdateCommand.Parameters.Add(new NpgsqlParameter()
{
SourceColumn = "id", ParameterName = "@id"
});
adapter.UpdateCommand.Parameters.Add(new NpgsqlParameter()
{
SourceColumn = "name", ParameterName = "@name"
});
adapter.UpdateCommand.Parameters.Add(new NpgsqlParameter()
{
SourceColumn = "date_add", ParameterName = "@date_add"
});
adapter.UpdateCommand.Parameters.Add(new NpgsqlParameter()
{
SourceColumn = "description", ParameterName = "@description"
});
adapter.UpdateCommand.Parameters.Add(new NpgsqlParameter()
{
SourceColumn = "person", ParameterName = "@person"
});
adapter.UpdateCommand.Parameters.Add(new NpgsqlParameter()
{
SourceColumn = "model", ParameterName = "@model"
});
adapter.DeleteCommand = new NpgsqlCommand(deletion, connection.GetConnection(), transaction.GetTransaction());
adapter.DeleteCommand.Parameters.Add(new NpgsqlParameter()
{
SourceColumn = "id", ParameterName = "@id"
});
NpgsqlCommandBuilder commandBuilder = new NpgsqlCommandBuilder(adapter);
adapter.Update(dataSet, "job");
}
public override IVitalsDao getVitalsDao(AbstractConnection cxn)
{
return(new VistaVitalsDao(cxn));
}
public override IToolsDao getToolsDao(AbstractConnection cxn)
{
return(new VistaToolsDao(cxn));;
}
public override IClinicalDao getClinicalDao(AbstractConnection cxn)
{
return(new VistaClinicalDao(cxn));
}
public override IOrdersDao getOrdersDao(AbstractConnection cxn)
{
return(new VistaOrdersDao(cxn));
}
public override void WriteEndVersion(Process process, AbstractConnection input, Entity entity, bool force = false)
{
//nope
}
public Dictionary <string, HashSet <string> > getUpdatedChemHemReports(AbstractConnection cxn, DateTime fromDate)
{
gov.va.medora.mdo.dao.sql.cdw.CdwChemHemDao dao = new dao.sql.cdw.CdwChemHemDao(cxn);
return(dao.getNewChemHemReports(fromDate));
}
public static Dictionary <string, AbstractPermission> getPermissions(AbstractConnection cxn, string uid, PermissionType type)
{
return(getDao(cxn).getPermissions(type, uid));
}
public override IChemHemDao getChemHemDao(AbstractConnection cxn)
{
return(new VistaChemHemDao(cxn));
}
public VistaLocationDao(AbstractConnection cxn)
{
this.cxn = cxn;
}
protected OutputCommandOperation(AbstractConnection connection) : base(connection)
{
}
public override IPatientDao getPatientDao(AbstractConnection cxn)
{
return(new VistaPatientDao(cxn));
}
public static bool hasPermission(AbstractConnection cxn, string userId, AbstractPermission permission)
{
return(getDao(cxn).hasPermission(userId, permission));
}
public bool Exists(AbstractConnection connection, Entity entity)
{
return(false);
}
public override IOrdersDao getOrdersDao(AbstractConnection cxn)
{
return(null);
}
public override INoteDao getNoteDao(AbstractConnection cxn)
{
return(new VistaNoteDao(cxn));
}
