Esempio n. 1
0
        public static void handleOutgoingHL7MessageToBrokerV1(string hl7Input,
                                                              Communication databaseCommunication,
                                                              HL7Broker.Model.Socket socket)
        {
            Dictionary <int, int> databaseTableRelationDictionary
                = new Dictionary <int, int>();

            // get all database table relations
            List <DatabaseTableRelation> relations = DatabaseTableRelationDAO.Get();

            // this identity is used for multiple inserts
            int identityNo = -1;

            // text
            string baseCommandText = BLANK;
            string tableName       = BLANK;
            // these will help build the custom query
            List <string> columns      = new List <string>();
            List <string> columnValues = new List <string>();

            // get message
            HL7Message hl7Message = socket.getHL7Message();

            // get configurations for the database comminucation
            List <Configuration> configurations
                = ConfigurationDAO.GetDatabaseConfiguration(databaseCommunication);

            // get the credential
            Credential credential = configurations[ZERO_ELEMENT].credential;

            // get the database instance
            DatabaseInstance databaseInstance = configurations[ZERO_ELEMENT].databaseInstance;

            // build the connection string
            string connectionString = DAOUtility.GetConnectionString(credential,
                                                                     databaseInstance, true);


            // build database query to insert data into tables based on configuration
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                try
                {
                    // get a list of databses tables
                    List <Configuration> configDatabaseTables
                        = ConfigurationDAO.GetDatabaseTables(databaseInstance);

                    // pick up all the tables for the config
                    configDatabaseTables.ForEach(delegate(Configuration tableConfig)
                    {
                        // empty the db value
                        string dbValue = BLANK;
                        // reset variables
                        baseCommandText = BLANK;
                        // empty the stores
                        columns.Clear();
                        columnValues.Clear();

                        SqlCommand command = new SqlCommand();

                        // set the database table
                        DatabaseTable table = tableConfig.databaseTable;

                        // init database table relation
                        DatabaseTableRelation databaseTableRelation = tableConfig.databaseTableRelation;

                        // based on the table instance id , get the column set
                        List <Configuration> configDatabaseColumns
                            = ConfigurationDAO.GetDatabaseColumns(table);

                        // set the table name
                        tableName = table.name;

                        // for each column, get the column name
                        configDatabaseColumns.ForEach(delegate(Configuration configColumn)
                        {
                            // set the column
                            ColumnSet column = configColumn.columnSet;

                            // get the data type to use
                            SqlDbType sqlDbType = DAOUtility.GetSqlDataType(column.columnDataType);

                            // if it's 0, there must be some special condition here, such as a primary key or handling a specific data type
                            if (column.messageGroupInstanceId == ZERO &&
                                column.columnDataType == INTEGER_TYPE)
                            {
                                // if the source table does have a relationship, then we need to get it
                                if (relations.Count(x => x.sourceDatabaseTableId == table.id) > ZERO)
                                {
                                    if (column.isPrimaryKey)
                                    {
                                        // do something here
                                        int keyValue = -1;

                                        // get the target table based on the source table
                                        int targetTableId = relations.Find(r => r.sourceDatabaseTableId ==
                                                                           table.id).targetDatabaseTableId;

                                        // get the identity
                                        databaseTableRelationDictionary.TryGetValue(targetTableId, out keyValue);

                                        // set the keyvalue to the db value
                                        dbValue = keyValue.ToString();
                                    }
                                    else
                                    {
                                        // Throw Error - there is an issue if the column value is of interger type but no
                                        // key is assoicated it it.
                                    }
                                }
                            }
                            // if this isn't bound to a column and it's of type text - then it should ALWAYS be an HL7 Message
                            else if (column.messageGroupInstanceId == ZERO &&
                                     column.columnDataType == TEXT_TYPE)
                            {
                                // apply hl7 message
                                dbValue = hl7Input;
                            }
                            // database column is of current date type, so we set the value to the current date time
                            else if (column.messageGroupInstanceId == ZERO &&
                                     column.columnDataType == DATE_TYPE)
                            {
                                // set the value to the current date time
                                dbValue = DateTime.Now.ToString();
                            }
                            // search for it by hl7 position
                            else
                            {
                                // init a message group instance
                                MessageGroupInstance messageGroupInstance = new MessageGroupInstance()
                                {
                                    id = column.messageGroupInstanceId
                                };

                                // reset the message group instance
                                configColumn.messageGroupInstance = messageGroupInstance;

                                // get the message position for this specific column
                                List <Configuration> configMessagePoisition
                                    = ConfigurationDAO.GetMessagePosition(configColumn.messageGroupInstance);

                                // get the coordinates for the message item
                                string messageCoordinates = HL7MessageUtility.getItemCoordinates(configMessagePoisition);

                                // get segment string type
                                string columnSegment = configMessagePoisition[ZERO_ELEMENT].segmentType.name;

                                // get the value for the database inside of the value position
                                string hl7Value = HL7MessageUtility.getValueByPosition(
                                    hl7Message,
                                    HL7MessageUtility.getSegmentType(columnSegment),
                                    messageCoordinates);

                                // generate the value
                                dbValue = (!String.IsNullOrEmpty(hl7Value) ? hl7Value : DBNull.Value.ToString());
                            }

                            // initialize for each new table
                            baseCommandText
                                = DAOUtility.GetBaseQuery(DAOUtility.SERVICE_QUERY_TYPE.INSERT);

                            // add to columns statement
                            columns.Add(column.name);

                            // add to values statement
                            columnValues.Add(AT_SIGN + column.name);

                            // set the command string
                            command.Parameters.Add(AT_SIGN + column.name, sqlDbType);

                            // set the values
                            command.Parameters[AT_SIGN + column.name].Value = dbValue;
                        });

                        // open the connection
                        connection.Open();

                        // grab command text
                        command.CommandText = DAOUtility.GetStatement(DAOUtility.SERVICE_QUERY_TYPE.INSERT,
                                                                      baseCommandText,
                                                                      tableName,
                                                                      columns,
                                                                      columnValues);

                        // make new transaction to allow roll back
                        SqlTransaction transaction = connection.BeginTransaction();

                        // initialize the connection
                        command.Connection = connection;

                        // initialize the transaction
                        command.Transaction = transaction;

                        // handle the database insert for message header instance
                        handleDatabaseTableCaller(connection,
                                                  command,
                                                  transaction,
                                                  hl7Message,
                                                  table,
                                                  hl7Input,
                                                  socket,
                                                  out identityNo);

                        // if the "database table has dependencies" - store the relation id w/ the table id
                        if (databaseTableRelation.id != ZERO)
                        {
                            // or in better terms - has a dependency that this ide requires
                            if (databaseTableRelation.requiresIdentity)
                            {
                                // add to the dictionary if it does require depdents
                                databaseTableRelationDictionary.Add(table.id, identityNo);
                            }
                            else
                            {
                                // reset if it doesn't need it
                                identityNo = NEG_ONE;
                            }
                        }
                    });
                }
                catch (SqlException sqlex)
                {
                    ErrorLogger.LogError(sqlex, "handleOutgoingHL7MessageToBroker()", hl7Input);
                    connection.Close();
                }
            }
        }
        private static bool copyOutgoingDatabase(Application inFromApplication,
                                                 Application inToApplication,
                                                 string directionType,
                                                 string communicationType)
        {
            try
            {
                int toApplicationIdentity   = inFromApplication.id;
                int fromApplicationIdentity = inToApplication.id;
                // get all applications
                List <Configuration> applicationList = ConfigurationDAO.GetApplications(new Application()
                {
                    id = fromApplicationIdentity
                });

                // get all communuication and direction Types
                Configuration masterConfigration = ConfigurationDAO.GetAllConfigurations();

                // get the specific application direction and comm you want
                Configuration fromApplication = applicationList.Find(a => a.communicationType.name == communicationType &&
                                                                     a.directionType.name == directionType);


                // communication translation identities
                int toDirectionTypeId =
                    masterConfigration.directionTypes.Find(d => d.name == fromApplication.directionType.name).id;
                int toCommunicationTypeId =
                    masterConfigration.communicationTypes.Find(c => c.name == fromApplication.communicationType.name).id;

                // create a new application object with your current application identity
                Application toApplication = new Application()
                {
                    id = toApplicationIdentity
                };

                // insert a new communication with your exsisting application
                Communication toCommunication =
                    CommunicationDAO.PostUpdate(new Communication()
                {
                    applicationId       = toApplication.id,
                    communicationTypeId = toCommunicationTypeId,
                    directionTypeId     = toDirectionTypeId
                });


                // get the database_instance information (credential id, name, server, ip) of the communication identity.
                DatabaseInstance fromDatabaseInstance =
                    masterConfigration.databaseInstances.Find(i => i.communicationId == fromApplication.communication.id);

                // get database_instance id of the copy from insert into new database_instance with info prior step
                DatabaseInstance toDatabaseInstance = new DatabaseInstance();

                // copy individual values as not top copy the reference (we need it later)
                toDatabaseInstance = fromDatabaseInstance.ShallowCopy();

                // override the communication id w/ the "to" communication id
                toDatabaseInstance.id = 0;
                toDatabaseInstance.communicationId = toCommunication.id;
                // insert new database instance - get the id from this request
                toDatabaseInstance = DatabaseInstanceDAO.PostUpdate(toDatabaseInstance);

                // get all database tables from the fromDatabaseInstance
                List <Configuration> fromDatabaseTables = ConfigurationDAO.GetDatabaseTables(fromDatabaseInstance);

                // get the database table relations
                List <DatabaseTableRelation> databaseTableRelations = masterConfigration.databaseTableRelations;

                // create a new database relation object
                DatabaseTableRelation databaseTableRelation = new DatabaseTableRelation()
                {
                    id = 0,
                    requiresIdentity      = true,
                    sourceDatabaseTableId = -1,
                    targetDatabaseTableId = -1
                };

                // foreach table that belongs to the from database_instance, get the from database_table information
                fromDatabaseTables.ForEach(delegate(Configuration configurationTable)
                {
                    // extract the database table from the configuration
                    DatabaseTable fromDatabaseTable = new DatabaseTable()
                    {
                        id = configurationTable.databaseTable.id,
                        databaseInstanceId = fromDatabaseInstance.id,
                        name = configurationTable.databaseTable.name
                    };

                    // create new database table
                    DatabaseTable toDatabaseTable = new DatabaseTable()
                    {
                        databaseInstanceId = toDatabaseInstance.id,
                        name = fromDatabaseTable.name
                    };

                    // insert new table into database_table with fromDatabaseTable information but use toDatabaseInstanceId
                    toDatabaseTable = DatabaseTableDAO.PostUpdate(toDatabaseTable);

                    // check for prior source relation
                    if (ConfigurationUtility.IsDatabaseTableRelation(configurationTable.databaseTable, databaseTableRelations))
                    {
                        databaseTableRelation.sourceDatabaseTableId = toDatabaseTable.id;
                    }

                    // check for prior target relation
                    if (ConfigurationUtility.IsDatabaseTableRelation(configurationTable.databaseTable, databaseTableRelations, true))
                    {
                        databaseTableRelation.targetDatabaseTableId = toDatabaseTable.id;
                    }

                    // based on the fromDatabaseTable get all column sets
                    List <Configuration> fromColumnSets = ConfigurationDAO.GetDatabaseColumns(fromDatabaseTable);

                    // foreach columnset that belongs to fromDatabaseColumn copy all information (except for the fromDatabaseTableId)
                    fromColumnSets.ForEach(delegate(Configuration configurationColumnSet)
                    {
                        // define the column set
                        ColumnSet fromColumnSet = new ColumnSet();
                        ColumnSet toColumnSet   = new ColumnSet();

                        // get the column set from the configuration list
                        fromColumnSet = configurationColumnSet.columnSet;
                        fromColumnSet.databaseTableId = configurationColumnSet.databaseTable.id;

                        // do a shallow copy of its properties and override the ones you need
                        toColumnSet    = fromColumnSet.ShallowCopy();
                        toColumnSet.id = 0;
                        toColumnSet.databaseTableId = toDatabaseTable.id;

                        // insert new toColumnSet using new toDAtabaseTable.id
                        toColumnSet = ColumnSetDAO.PostUpdate(toColumnSet);
                    });
                });

                // if relation source or target is not negative one - insert new relation
                if (databaseTableRelation.sourceDatabaseTableId != -1 &&
                    databaseTableRelation.targetDatabaseTableId != -1)
                {
                    databaseTableRelation = DatabaseTableRelationDAO.PostUpdate(databaseTableRelation);
                }
            }
            catch (Exception ex)
            {
                string fromApplicationId = inFromApplication.id.ToString();
                string toApplicationId   = inToApplication.id.ToString();
                ErrorLogger.LogError(ex,
                                     "CopyConfigurationUtility.CopyOutgoingDatabase(fromApplication, toApplication, directionType,communicationType)",
                                     fromApplicationId + "|" +
                                     toApplicationId + "|" +
                                     directionType + "|" +
                                     communicationType);

                return(false);
            }

            return(true);
        }