/// <summary>
        /// Select values from TitleAssociation_TitleIdentifier by primary key(s).
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <param name="connectionKeyName">Connection key name located in config file.</param>
        /// <param name="titleAssociation_TitleIdentifierID"></param>
        /// <returns>Object of type TitleAssociation_TitleIdentifier.</returns>
        public TitleAssociation_TitleIdentifier TitleAssociation_TitleIdentifierSelectAuto(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            string connectionKeyName,
            int titleAssociation_TitleIdentifierID)
        {
            SqlConnection  connection  = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings(connectionKeyName), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("TitleAssociation_TitleIdentifierSelectAuto", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("TitleAssociation_TitleIdentifierID", SqlDbType.Int, null, false, titleAssociation_TitleIdentifierID)))
            {
                using (CustomSqlHelper <TitleAssociation_TitleIdentifier> helper = new CustomSqlHelper <TitleAssociation_TitleIdentifier>())
                {
                    CustomGenericList <TitleAssociation_TitleIdentifier> list = helper.ExecuteReader(command);
                    if (list.Count > 0)
                    {
                        TitleAssociation_TitleIdentifier o = list[0];
                        list = null;
                        return(o);
                    }
                    else
                    {
                        return(null);
                    }
                }
            }
        }
Ejemplo n.º 2
0
        public static int PageNameCountUniqueConfirmedBetweenDates(SqlConnection sqlConnection, SqlTransaction sqlTransaction,
                                                                   DateTime startDate, DateTime endDate)
        {
            SqlConnection  connection  = sqlConnection;
            SqlTransaction transaction = sqlTransaction;

            if (connection == null)
            {
                connection = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"));
            }

            using (SqlCommand command = CustomSqlHelper.CreateCommand("PageNameCountUniqueConfirmedBetweenDates", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("StartDate", SqlDbType.DateTime, null, false, startDate),
                                                                      CustomSqlHelper.CreateInputParameter("EndDate", SqlDbType.DateTime, null, false, endDate)))
            {
                using (CustomSqlHelper <int> helper = new CustomSqlHelper <int>())
                {
                    CustomGenericList <int> list = helper.ExecuteReader(command);

                    if (list.Count == 0)
                    {
                        return(default(int));
                    }
                    else
                    {
                        return(list[0]);
                    }
                }
            }
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Select values from MonthlyStats by primary key(s).
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <param name="connectionKeyName">Connection key name located in config file.</param>
        /// <param name="year"></param>
        /// <param name="month"></param>
        /// <param name="institutionName"></param>
        /// <param name="statType"></param>
        /// <returns>Object of type MonthlyStats.</returns>
        public MonthlyStats MonthlyStatsSelectAuto(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            string connectionKeyName,
            int year,
            int month,
            string institutionName,
            string statType)
        {
            SqlConnection  connection  = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings(connectionKeyName), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("MonthlyStatsSelectAuto", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("Year", SqlDbType.Int, null, false, year),
                                                                      CustomSqlHelper.CreateInputParameter("Month", SqlDbType.Int, null, false, month),
                                                                      CustomSqlHelper.CreateInputParameter("InstitutionName", SqlDbType.NVarChar, 255, false, institutionName),
                                                                      CustomSqlHelper.CreateInputParameter("StatType", SqlDbType.NVarChar, 100, false, statType)))
            {
                using (CustomSqlHelper <MonthlyStats> helper = new CustomSqlHelper <MonthlyStats>())
                {
                    CustomGenericList <MonthlyStats> list = helper.ExecuteReader(command);
                    if (list.Count > 0)
                    {
                        MonthlyStats o = list[0];
                        list = null;
                        return(o);
                    }
                    else
                    {
                        return(null);
                    }
                }
            }
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Select values from MarcDataField by primary key(s).
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <param name="connectionKeyName">Connection key name located in config file.</param>
        /// <param name="marcDataFieldID"></param>
        /// <returns>Object of type MarcDataField.</returns>
        public MarcDataField MarcDataFieldSelectAuto(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            string connectionKeyName,
            int marcDataFieldID)
        {
            SqlConnection  connection  = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings(connectionKeyName), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("MarcDataFieldSelectAuto", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("MarcDataFieldID", SqlDbType.Int, null, false, marcDataFieldID)))
            {
                using (CustomSqlHelper <MarcDataField> helper = new CustomSqlHelper <MarcDataField>())
                {
                    CustomGenericList <MarcDataField> list = helper.ExecuteReader(command);
                    if (list.Count > 0)
                    {
                        MarcDataField o = list[0];
                        list = null;
                        return(o);
                    }
                    else
                    {
                        return(null);
                    }
                }
            }
        }
Ejemplo n.º 5
0
        public Institution InstitutionSelectByItemID(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            int itemID)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection( CustomSqlHelper.GetConnectionStringFromConnectionStrings( "BHL" ), sqlConnection );
            SqlTransaction transaction = sqlTransaction;

            using ( SqlCommand command = CustomSqlHelper.CreateCommand( "InstitutionSelectByItemID", connection, transaction,
                    CustomSqlHelper.CreateInputParameter( "ItemID", SqlDbType.Int, null, false, itemID ) ) )
            {
                using ( CustomSqlHelper<Institution> helper = new CustomSqlHelper<Institution>() )
                {
                    CustomGenericList<Institution> list = helper.ExecuteReader( command );
                    if ( list.Count > 0 )
                    {
                        Institution o = list[ 0 ];
                        list = null;
                        return o;
                    }
                    else
                    {
                        return null;
                    }
                }
            }
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Update values in TitleLanguage. Returns an object of type TitleLanguage.
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <param name="connectionKeyName">Connection key name located in config file.</param>
        /// <param name="titleLanguageID"></param>
        /// <param name="titleID"></param>
        /// <param name="languageCode"></param>
        /// <returns>Object of type TitleLanguage.</returns>
        public TitleLanguage TitleLanguageUpdateAuto(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            string connectionKeyName,
            int titleLanguageID,
            int titleID,
            string languageCode)
        {
            SqlConnection  connection  = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings(connectionKeyName), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("TitleLanguageUpdateAuto", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("TitleLanguageID", SqlDbType.Int, null, false, titleLanguageID),
                                                                      CustomSqlHelper.CreateInputParameter("TitleID", SqlDbType.Int, null, false, titleID),
                                                                      CustomSqlHelper.CreateInputParameter("LanguageCode", SqlDbType.NVarChar, 10, false, languageCode),
                                                                      CustomSqlHelper.CreateReturnValueParameter("ReturnCode", SqlDbType.Int, null, false)))
            {
                using (CustomSqlHelper <TitleLanguage> helper = new CustomSqlHelper <TitleLanguage>())
                {
                    CustomGenericList <TitleLanguage> list = helper.ExecuteReader(command);
                    if (list.Count > 0)
                    {
                        TitleLanguage o = list[0];
                        list = null;
                        return(o);
                    }
                    else
                    {
                        return(null);
                    }
                }
            }
        }
Ejemplo n.º 7
0
        /// <summary>
        /// Select values from CreatorRoleType by primary key(s).
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <param name="creatorRoleTypeID">Unique identifier for each Creator Role Type.</param>
        /// <returns>Object of type CreatorRoleType.</returns>
        public CreatorRoleType CreatorRoleTypeSelectAuto(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            int creatorRoleTypeID)
        {
            SqlConnection  connection  = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("CreatorRoleTypeSelectAuto", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("CreatorRoleTypeID", SqlDbType.Int, null, false, creatorRoleTypeID)))
            {
                using (CustomSqlHelper <CreatorRoleType> helper = new CustomSqlHelper <CreatorRoleType>())
                {
                    CustomGenericList <CreatorRoleType> list = helper.ExecuteReader(command);
                    if (list.Count > 0)
                    {
                        CreatorRoleType o = list[0];
                        list = null;
                        return(o);
                    }
                    else
                    {
                        return(null);
                    }
                }
            }
        }
Ejemplo n.º 8
0
        /// <summary>
        /// Delete values from IndicatedPage by primary key(s).
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <param name="pageID">Unique identifier for each Page record.</param>
        /// <param name="sequence">A number to separately identify various series of Indicated Pages.</param>
        /// <returns>true if successful otherwise false.</returns>
        public bool IndicatedPageDeleteAuto(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            int pageID,
            short sequence)
        {
            SqlConnection  connection  = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("IndicatedPageDeleteAuto", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("PageID", SqlDbType.Int, null, false, pageID),
                                                                      CustomSqlHelper.CreateInputParameter("Sequence", SqlDbType.SmallInt, null, false, sequence),
                                                                      CustomSqlHelper.CreateReturnValueParameter("ReturnCode", SqlDbType.Int, null, false)))
            {
                int returnCode = CustomSqlHelper.ExecuteNonQuery(command, "ReturnCode");

                if (transaction == null)
                {
                    CustomSqlHelper.CloseConnection(connection);
                }

                if (returnCode == 0)
                {
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
        }
Ejemplo n.º 9
0
        /// <summary>
        /// Select values from Institution by primary key(s).
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <param name="connectionKeyName">Connection key name located in config file.</param>
        /// <param name="institutionCode">Code for Institution providing assistance.</param>
        /// <returns>Object of type Institution.</returns>
        public Institution InstitutionSelectAuto(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            string connectionKeyName,
            string institutionCode)
        {
            SqlConnection  connection  = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings(connectionKeyName), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("InstitutionSelectAuto", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("InstitutionCode", SqlDbType.NVarChar, 10, false, institutionCode)))
            {
                using (CustomSqlHelper <Institution> helper = new CustomSqlHelper <Institution>())
                {
                    CustomGenericList <Institution> list = helper.ExecuteReader(command);
                    if (list.Count > 0)
                    {
                        Institution o = list[0];
                        list = null;
                        return(o);
                    }
                    else
                    {
                        return(null);
                    }
                }
            }
        }
Ejemplo n.º 10
0
        /// <summary>
        /// Update the ItemSequence for the specified TitleItem.
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null</param>
        /// <param name="sqlTransaction">Sql transaction or null</param>
        /// <param name="titleID">Identifier of a specific title</param>
        /// <param name="itemID">Identifier of a specific item</param>
        /// <param name="itemSequence">ItemSequence value</param>
        /// <returns>The updated titleitem</returns>
        public TitleItem TitleItemUpdateItemSequence(SqlConnection sqlConnection, SqlTransaction sqlTransaction,
                                                     int titleID, int itemID, short?itemSequence)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(
                CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("TitleItemUpdateItemSequence", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("TitleID", SqlDbType.Int, null, false, titleID),
                                                                      CustomSqlHelper.CreateInputParameter("ItemID", SqlDbType.Int, null, false, itemID),
                                                                      CustomSqlHelper.CreateInputParameter("ItemSequence", SqlDbType.SmallInt, null, true, itemSequence)))
            {
                using (CustomSqlHelper <TitleItem> helper = new CustomSqlHelper <TitleItem>())
                {
                    CustomGenericList <TitleItem> list = helper.ExecuteReader(command);
                    if (list.Count > 0)
                    {
                        return(list[0]);
                    }
                    else
                    {
                        return(null);
                    }
                }
            }
        }
Ejemplo n.º 11
0
        /// <summary>
        /// Select values from IndicatedPage by primary key(s).
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <param name="pageID">Unique identifier for each Page record.</param>
        /// <param name="sequence">A number to separately identify various series of Indicated Pages.</param>
        /// <returns>Object of type IndicatedPage.</returns>
        public IndicatedPage IndicatedPageSelectAuto(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            int pageID,
            short sequence)
        {
            SqlConnection  connection  = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("IndicatedPageSelectAuto", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("PageID", SqlDbType.Int, null, false, pageID),
                                                                      CustomSqlHelper.CreateInputParameter("Sequence", SqlDbType.SmallInt, null, false, sequence)))
            {
                using (CustomSqlHelper <IndicatedPage> helper = new CustomSqlHelper <IndicatedPage>())
                {
                    CustomGenericList <IndicatedPage> list = helper.ExecuteReader(command);
                    if (list.Count > 0)
                    {
                        IndicatedPage o = list[0];
                        list = null;
                        return(o);
                    }
                    else
                    {
                        return(null);
                    }
                }
            }
        }
Ejemplo n.º 12
0
        public bool IndicatedPageInsertNext(SqlConnection sqlConnection, SqlTransaction sqlTransaction, int pageID,
                                            string pagePrefix, string pageNumber, bool implied, int userId)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(
                CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("IndicatedPageInsertNext", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("PageID", SqlDbType.Int, null, false, pageID),
                                                                      CustomSqlHelper.CreateInputParameter("PagePrefix", SqlDbType.NVarChar, 20, true, pagePrefix),
                                                                      CustomSqlHelper.CreateInputParameter("PageNumber", SqlDbType.NVarChar, 20, true, pageNumber),
                                                                      CustomSqlHelper.CreateInputParameter("Implied", SqlDbType.Bit, null, false, implied),
                                                                      CustomSqlHelper.CreateInputParameter("CreationUserID", SqlDbType.Int, null, false, userId),
                                                                      CustomSqlHelper.CreateInputParameter("LastModifiedUserID", SqlDbType.Int, null, false, userId),
                                                                      CustomSqlHelper.CreateReturnValueParameter("ReturnCode", SqlDbType.Int, null, false)))
            {
                int returnCode = CustomSqlHelper.ExecuteNonQuery(command, "ReturnCode");

                if (transaction == null)
                {
                    CustomSqlHelper.CloseConnection(connection);
                }

                if (returnCode == 0)
                {
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
        }
Ejemplo n.º 13
0
        public bool IndicatedPageDeleteAllForPage(SqlConnection sqlConnection, SqlTransaction sqlTransaction, int pageID)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(
                CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            try
            {
                using (SqlCommand command =
                           CustomSqlHelper.CreateCommand("IndicatedPageDeleteAllForPage", connection, sqlTransaction,
                                                         CustomSqlHelper.CreateInputParameter("PageID", SqlDbType.Int, null, false, pageID),
                                                         CustomSqlHelper.CreateReturnValueParameter("ReturnCode", SqlDbType.Int, null, false)))
                {
                    int returnCode = CustomSqlHelper.ExecuteNonQuery(command, "ReturnCode");

                    if (transaction == null)
                    {
                        CustomSqlHelper.CloseConnection(connection);
                    }

                    if (returnCode == 0)
                    {
                        return(true);
                    }
                    else
                    {
                        return(false);
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception("Exception in IndicatedPageDeleteAllForPage", ex);
            }
        }
Ejemplo n.º 14
0
        /// <summary>
        /// Select values from PDFStatus by primary key(s).
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <param name="connectionKeyName">Connection key name located in config file.</param>
        /// <param name="pdfStatusID"></param>
        /// <returns>Object of type PDFStatus.</returns>
        public PDFStatus PDFStatusSelectAuto(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            string connectionKeyName,
            int pdfStatusID)
        {
            SqlConnection  connection  = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings(connectionKeyName), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("PDFStatusSelectAuto", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("PdfStatusID", SqlDbType.Int, null, false, pdfStatusID)))
            {
                using (CustomSqlHelper <PDFStatus> helper = new CustomSqlHelper <PDFStatus>())
                {
                    CustomGenericList <PDFStatus> list = helper.ExecuteReader(command);
                    if (list.Count > 0)
                    {
                        PDFStatus o = list[0];
                        list = null;
                        return(o);
                    }
                    else
                    {
                        return(null);
                    }
                }
            }
        }
Ejemplo n.º 15
0
        public Title_TitleIdentifier Title_TitleIdentifierSelectByIdentifierValue(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            string identifierValue)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(
                CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("Title_TitleIdentifierSelectByIdentifierValue", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("IdentifierValue", SqlDbType.NVarChar, 125, false, identifierValue)))
            {
                using (CustomSqlHelper <Title_TitleIdentifier> helper = new CustomSqlHelper <Title_TitleIdentifier>())
                {
                    CustomGenericList <Title_TitleIdentifier> list = helper.ExecuteReader(command);
                    if (list.Count > 0)
                    {
                        return(list[0]);
                    }
                    else
                    {
                        return(null);
                    }
                }
            }
        }
Ejemplo n.º 16
0
        public Title MarcSelectTitleDetailsByMarcID(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            int marcId)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(
                CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("MarcSelectTitleDetailsByMarcID", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("MarcID", SqlDbType.Int, null, false, marcId)))
            {
                using (CustomSqlHelper <Title> helper = new CustomSqlHelper <Title>())
                {
                    CustomGenericList <Title> list = helper.ExecuteReader(command);
                    if (list.Count > 0)
                    {
                        return(list[0]);
                    }
                    else
                    {
                        return(null);
                    }
                }
            }
        }
Ejemplo n.º 17
0
 public void Dispose()
 {
     if (connection != null)
     {
         CustomSqlHelper.CloseConnection(connection);
     }
 }
Ejemplo n.º 18
0
        public Creator CreatorSelectByCreatorName(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            string creatorName)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection( CustomSqlHelper.GetConnectionStringFromConnectionStrings( "BHL" ), sqlConnection );
              SqlTransaction transaction = sqlTransaction;

              using ( SqlCommand command = CustomSqlHelper.CreateCommand( "CreatorSelectByCreatorName", connection, transaction,
              CustomSqlHelper.CreateInputParameter( "CreatorName", SqlDbType.NVarChar, 255, false, creatorName ) ) )
              {
            using ( CustomSqlHelper<Creator> helper = new CustomSqlHelper<Creator>() )
            {
              CustomGenericList<Creator> list = helper.ExecuteReader( command );
              if ( list.Count > 0 )
              {
            return list[ 0 ];
              }
              else
              {
            return null;
              }
            }
              }
        }
Ejemplo n.º 19
0
        /// <summary>
        /// Delete values from CreatorRoleType by primary key(s).
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <param name="creatorRoleTypeID">Unique identifier for each Creator Role Type.</param>
        /// <returns>true if successful otherwise false.</returns>
        public bool CreatorRoleTypeDeleteAuto(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            int creatorRoleTypeID)
        {
            SqlConnection  connection  = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("CreatorRoleTypeDeleteAuto", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("CreatorRoleTypeID", SqlDbType.Int, null, false, creatorRoleTypeID),
                                                                      CustomSqlHelper.CreateReturnValueParameter("ReturnCode", SqlDbType.Int, null, false)))
            {
                int returnCode = CustomSqlHelper.ExecuteNonQuery(command, "ReturnCode");

                if (transaction == null)
                {
                    CustomSqlHelper.CloseConnection(connection);
                }

                if (returnCode == 0)
                {
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
        }
Ejemplo n.º 20
0
        /// <summary>
        /// Update values in CreatorRoleType. Returns an object of type CreatorRoleType.
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <param name="creatorRoleTypeID">Unique identifier for each Creator Role Type.</param>
        /// <param name="creatorRoleType">A type of Role performed by a Creator.</param>
        /// <param name="creatorRoleTypeDescription">Description of a Creator Role Type.</param>
        /// <param name="mARCDataFieldTag">Data Field Tag from MARC XML.</param>
        /// <returns>Object of type CreatorRoleType.</returns>
        public CreatorRoleType CreatorRoleTypeUpdateAuto(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            int creatorRoleTypeID,
            string creatorRoleType,
            string creatorRoleTypeDescription,
            string mARCDataFieldTag)
        {
            SqlConnection  connection  = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("CreatorRoleTypeUpdateAuto", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("CreatorRoleTypeID", SqlDbType.Int, null, false, creatorRoleTypeID),
                                                                      CustomSqlHelper.CreateInputParameter("CreatorRoleType", SqlDbType.NVarChar, 25, false, creatorRoleType),
                                                                      CustomSqlHelper.CreateInputParameter("CreatorRoleTypeDescription", SqlDbType.NVarChar, 255, true, creatorRoleTypeDescription),
                                                                      CustomSqlHelper.CreateInputParameter("MARCDataFieldTag", SqlDbType.NVarChar, 3, true, mARCDataFieldTag),
                                                                      CustomSqlHelper.CreateReturnValueParameter("ReturnCode", SqlDbType.Int, null, false)))
            {
                using (CustomSqlHelper <CreatorRoleType> helper = new CustomSqlHelper <CreatorRoleType>())
                {
                    CustomGenericList <CreatorRoleType> list = helper.ExecuteReader(command);
                    if (list.Count > 0)
                    {
                        CreatorRoleType o = list[0];
                        list = null;
                        return(o);
                    }
                    else
                    {
                        return(null);
                    }
                }
            }
        }
Ejemplo n.º 21
0
        /// <summary>
        /// Update values in ItemStatus. Returns an object of type ItemStatus.
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <param name="itemStatusID"></param>
        /// <param name="itemStatusName"></param>
        /// <returns>Object of type ItemStatus.</returns>
        public ItemStatus ItemStatusUpdateAuto(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            int itemStatusID,
            string itemStatusName)
        {
            SqlConnection  connection  = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("ItemStatusUpdateAuto", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("ItemStatusID", SqlDbType.Int, null, false, itemStatusID),
                                                                      CustomSqlHelper.CreateInputParameter("ItemStatusName", SqlDbType.NVarChar, 50, false, itemStatusName),
                                                                      CustomSqlHelper.CreateReturnValueParameter("ReturnCode", SqlDbType.Int, null, false)))
            {
                using (CustomSqlHelper <ItemStatus> helper = new CustomSqlHelper <ItemStatus>())
                {
                    CustomGenericList <ItemStatus> list = helper.ExecuteReader(command);
                    if (list.Count > 0)
                    {
                        ItemStatus o = list[0];
                        list = null;
                        return(o);
                    }
                    else
                    {
                        return(null);
                    }
                }
            }
        }
Ejemplo n.º 22
0
        /// <summary>
        /// Select values from PageSummaryView by Barcode.
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <param name="barcode"></param>
        /// <returns>Object of type Title.</returns>
        public PageSummaryView PageSummarySelectByBarcode(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            string barcode)
        {
            SqlConnection  connection  = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("PageSummarySelectByBarcode", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("Barcode", SqlDbType.VarChar, 40, false, barcode)))
            {
                using (CustomSqlHelper <PageSummaryView> helper = new CustomSqlHelper <PageSummaryView>())
                {
                    CustomGenericList <PageSummaryView> list = helper.ExecuteReader(command);
                    if (list.Count > 0)
                    {
                        return(list[0]);
                    }
                    else
                    {
                        return(null);
                    }
                }
            }
        }
Ejemplo n.º 23
0
        public static int PageNameCountUniqueConfirmed(SqlConnection sqlConnection, SqlTransaction sqlTransaction)
        {
            SqlConnection  connection  = sqlConnection;
            SqlTransaction transaction = sqlTransaction;

            if (connection == null)
            {
                connection = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"));
            }

            using (SqlCommand command = CustomSqlHelper.CreateCommand("PageNameCountUniqueConfirmed", connection, transaction))
            {
                using (CustomSqlHelper <int> helper = new CustomSqlHelper <int>())
                {
                    CustomGenericList <int> list = helper.ExecuteReader(command);

                    if (list.Count == 0)
                    {
                        return(default(int));
                    }
                    else
                    {
                        return(list[0]);
                    }
                }
            }
        }
Ejemplo n.º 24
0
        /// <summary>
        /// Update values in TitleIdentifier. Returns an object of type TitleIdentifier.
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <param name="connectionKeyName">Connection key name located in config file.</param>
        /// <param name="titleIdentifierID"></param>
        /// <param name="identifierName"></param>
        /// <param name="marcDataFieldTag"></param>
        /// <param name="marcSubFieldCode"></param>
        /// <returns>Object of type TitleIdentifier.</returns>
        public TitleIdentifier TitleIdentifierUpdateAuto(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            string connectionKeyName,
            int titleIdentifierID,
            string identifierName,
            string marcDataFieldTag,
            string marcSubFieldCode)
        {
            SqlConnection  connection  = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings(connectionKeyName), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("TitleIdentifierUpdateAuto", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("TitleIdentifierID", SqlDbType.Int, null, false, titleIdentifierID),
                                                                      CustomSqlHelper.CreateInputParameter("IdentifierName", SqlDbType.NVarChar, 40, false, identifierName),
                                                                      CustomSqlHelper.CreateInputParameter("MarcDataFieldTag", SqlDbType.NVarChar, 50, false, marcDataFieldTag),
                                                                      CustomSqlHelper.CreateInputParameter("MarcSubFieldCode", SqlDbType.NVarChar, 50, false, marcSubFieldCode),
                                                                      CustomSqlHelper.CreateReturnValueParameter("ReturnCode", SqlDbType.Int, null, false)))
            {
                using (CustomSqlHelper <TitleIdentifier> helper = new CustomSqlHelper <TitleIdentifier>())
                {
                    CustomGenericList <TitleIdentifier> list = helper.ExecuteReader(command);
                    if (list.Count > 0)
                    {
                        TitleIdentifier o = list[0];
                        list = null;
                        return(o);
                    }
                    else
                    {
                        return(null);
                    }
                }
            }
        }
Ejemplo n.º 25
0
        /// <summary>
        /// Delete values from Institution by primary key(s).
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <param name="connectionKeyName">Connection key name located in config file.</param>
        /// <param name="institutionCode">Code for Institution providing assistance.</param>
        /// <returns>true if successful otherwise false.</returns>
        public bool InstitutionDeleteAuto(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            string connectionKeyName,
            string institutionCode)
        {
            SqlConnection  connection  = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings(connectionKeyName), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("InstitutionDeleteAuto", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("InstitutionCode", SqlDbType.NVarChar, 10, false, institutionCode),
                                                                      CustomSqlHelper.CreateReturnValueParameter("ReturnCode", SqlDbType.Int, null, false)))
            {
                int returnCode = CustomSqlHelper.ExecuteNonQuery(command, "ReturnCode");

                if (transaction == null)
                {
                    CustomSqlHelper.CloseConnection(connection);
                }

                if (returnCode == 0)
                {
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
        }
Ejemplo n.º 26
0
        public static int PageNameCountUniqueConfirmed(SqlConnection sqlConnection, SqlTransaction sqlTransaction)
        {
            SqlConnection connection = sqlConnection;
            SqlTransaction transaction = sqlTransaction;

            if (connection == null)
            {
                connection = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"));
            }

            using (SqlCommand command = CustomSqlHelper.CreateCommand("PageNameCountUniqueConfirmed", connection, transaction))
            {
                using (CustomSqlHelper<int> helper = new CustomSqlHelper<int>())
                {
                    CustomGenericList<int> list = helper.ExecuteReader(command);

                    if (list.Count == 0)
                    {
                        return default(int);
                    }
                    else
                    {
                        return list[0];
                    }
                }
            }
        }
Ejemplo n.º 27
0
        public static int PageNameCountUniqueConfirmedBetweenDates(SqlConnection sqlConnection, SqlTransaction sqlTransaction, 
            DateTime startDate, DateTime endDate)
        {
            SqlConnection connection = sqlConnection;
            SqlTransaction transaction = sqlTransaction;

            if (connection == null)
            {
                connection = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"));
            }

            using (SqlCommand command = CustomSqlHelper.CreateCommand("PageNameCountUniqueConfirmedBetweenDates", connection, transaction,
                CustomSqlHelper.CreateInputParameter("StartDate", SqlDbType.DateTime, null, false, startDate),
                CustomSqlHelper.CreateInputParameter("EndDate", SqlDbType.DateTime, null, false, endDate)))
            {
                using (CustomSqlHelper<int> helper = new CustomSqlHelper<int>())
                {
                    CustomGenericList<int> list = helper.ExecuteReader(command);

                    if (list.Count == 0)
                    {
                        return default(int);
                    }
                    else
                    {
                        return list[0];
                    }
                }
            }
        }
Ejemplo n.º 28
0
        /// <summary>
        /// Select all Creators for a BibId.
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <returns>Object of type Creator.</returns>
        private Stats StatsSelect(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            bool expanded,
            bool names)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(
                CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("StatsSelect", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("Expanded", SqlDbType.Bit, null, false, expanded),
                                                                      CustomSqlHelper.CreateInputParameter("Names", SqlDbType.Bit, null, false, names)))
            {
                CustomGenericList <CustomDataRow> list = CustomSqlHelper.ExecuteReaderAndReturnRows(command);
                CustomDataRow row   = list[0];
                Stats         stats = new Stats();
                stats.TitleCount  = (int)row["TitleCount"].Value;
                stats.VolumeCount = (int)row["VolumeCount"].Value;
                stats.PageCount   = (int)row["PageCount"].Value;
                stats.PageTotal   = (int)row["PageTotal"].Value;
                stats.TitleTotal  = (int)row["TitleTotal"].Value;
                stats.VolumeTotal = (int)row["VolumeTotal"].Value;
                stats.UniqueCount = (int)row["UniqueCount"].Value;
                stats.UniqueTotal = (int)row["UniqueTotal"].Value;

                return(stats);
            }
        }
Ejemplo n.º 29
0
        /// <summary>
        /// Update values in MarcSubField. Returns an object of type MarcSubField.
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <param name="connectionKeyName">Connection key name located in config file.</param>
        /// <param name="marcSubFieldID"></param>
        /// <param name="marcDataFieldID"></param>
        /// <param name="code"></param>
        /// <param name="value"></param>
        /// <returns>Object of type MarcSubField.</returns>
        public MarcSubField MarcSubFieldUpdateAuto(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            string connectionKeyName,
            int marcSubFieldID,
            int marcDataFieldID,
            string code,
            string value)
        {
            SqlConnection  connection  = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings(connectionKeyName), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("MarcSubFieldUpdateAuto", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("MarcSubFieldID", SqlDbType.Int, null, false, marcSubFieldID),
                                                                      CustomSqlHelper.CreateInputParameter("MarcDataFieldID", SqlDbType.Int, null, false, marcDataFieldID),
                                                                      CustomSqlHelper.CreateInputParameter("Code", SqlDbType.NChar, 1, false, code),
                                                                      CustomSqlHelper.CreateInputParameter("Value", SqlDbType.NVarChar, 200, false, value),
                                                                      CustomSqlHelper.CreateReturnValueParameter("ReturnCode", SqlDbType.Int, null, false)))
            {
                using (CustomSqlHelper <MarcSubField> helper = new CustomSqlHelper <MarcSubField>())
                {
                    CustomGenericList <MarcSubField> list = helper.ExecuteReader(command);
                    if (list.Count > 0)
                    {
                        MarcSubField o = list[0];
                        list = null;
                        return(o);
                    }
                    else
                    {
                        return(null);
                    }
                }
            }
        }
        /// <summary>
        /// Delete values from TitleAssociation_TitleIdentifier by primary key(s).
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <param name="connectionKeyName">Connection key name located in config file.</param>
        /// <param name="titleAssociation_TitleIdentifierID"></param>
        /// <returns>true if successful otherwise false.</returns>
        public bool TitleAssociation_TitleIdentifierDeleteAuto(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            string connectionKeyName,
            int titleAssociation_TitleIdentifierID)
        {
            SqlConnection  connection  = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings(connectionKeyName), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("TitleAssociation_TitleIdentifierDeleteAuto", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("TitleAssociation_TitleIdentifierID", SqlDbType.Int, null, false, titleAssociation_TitleIdentifierID),
                                                                      CustomSqlHelper.CreateReturnValueParameter("ReturnCode", SqlDbType.Int, null, false)))
            {
                int returnCode = CustomSqlHelper.ExecuteNonQuery(command, "ReturnCode");

                if (transaction == null)
                {
                    CustomSqlHelper.CloseConnection(connection);
                }

                if (returnCode == 0)
                {
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
        }
Ejemplo n.º 31
0
        /// <summary>
        /// Select values from PageTitleSummaryView by MARC Bib Id.
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <param name="bibID"></param>
        /// <returns>Object of type Title.</returns>
        public PageSummaryView PageTitleSummarySelectByBibId(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            string bibID)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection( CustomSqlHelper.GetConnectionStringFromConnectionStrings( "BHL" ), sqlConnection );
              SqlTransaction transaction = sqlTransaction;

              using ( SqlCommand command = CustomSqlHelper.CreateCommand( "PageTitleSummarySelectByBibId", connection, transaction,
              CustomSqlHelper.CreateInputParameter( "BibID", SqlDbType.VarChar, 50, false, bibID ) ) )
              {
              using (CustomSqlHelper<PageSummaryView> helper = new CustomSqlHelper<PageSummaryView>())
            {
            CustomGenericList<PageSummaryView> list = helper.ExecuteReader(command);
              if ( list.Count > 0 )
              {
            return list[ 0 ];
              }
              else
              {
            return null;
              }
            }
              }
        }
Ejemplo n.º 32
0
        /// <summary>
        /// Insert values into TitleType.
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <param name="titleTypeID">Unique identifier for each Title Type record.</param>
        /// <param name="titleType">A Type to be associated with a Title.</param>
        /// <param name="titleTypeDescription">Description of a Title Type.</param>
        /// <returns>Object of type TitleType.</returns>
        public TitleType TitleTypeInsertAuto(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            int titleTypeID,
            string titleType,
            string titleTypeDescription)
        {
            SqlConnection  connection  = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("TitleTypeInsertAuto", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("TitleTypeID", SqlDbType.Int, null, false, titleTypeID),
                                                                      CustomSqlHelper.CreateInputParameter("TitleType", SqlDbType.NVarChar, 25, false, titleType),
                                                                      CustomSqlHelper.CreateInputParameter("TitleTypeDescription", SqlDbType.NVarChar, 80, true, titleTypeDescription),
                                                                      CustomSqlHelper.CreateReturnValueParameter("ReturnCode", SqlDbType.Int, null, false)))
            {
                using (CustomSqlHelper <TitleType> helper = new CustomSqlHelper <TitleType>())
                {
                    CustomGenericList <TitleType> list = helper.ExecuteReader(command);
                    if (list.Count > 0)
                    {
                        TitleType o = list[0];
                        list = null;
                        return(o);
                    }
                    else
                    {
                        return(null);
                    }
                }
            }
        }
Ejemplo n.º 33
0
        public CustomGenericList <OpenUrlCitation> OpenUrlCitationSelectByTitleDetails(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            string title,
            string authorLast,
            string authorFirst,
            string authorCorporation,
            string publisherName,
            string publisherPlace,
            string publisher)
        {
            SqlConnection  connection  = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("OpenUrlCitationSelectByTitleDetails", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("Title", SqlDbType.NVarChar, 2000, true, title),
                                                                      CustomSqlHelper.CreateInputParameter("AuthorLast", SqlDbType.NVarChar, 150, true, authorLast),
                                                                      CustomSqlHelper.CreateInputParameter("AuthorFirst", SqlDbType.NVarChar, 100, true, authorFirst),
                                                                      CustomSqlHelper.CreateInputParameter("AuthorCorporation", SqlDbType.NVarChar, 255, true, authorCorporation),
                                                                      CustomSqlHelper.CreateInputParameter("PublisherName", SqlDbType.NVarChar, 255, true, publisherName),
                                                                      CustomSqlHelper.CreateInputParameter("PublisherPlace", SqlDbType.NVarChar, 150, true, publisherPlace),
                                                                      CustomSqlHelper.CreateInputParameter("Publisher", SqlDbType.NVarChar, 255, true, publisher)))
            {
                CustomGenericList <CustomDataRow> list = CustomSqlHelper.ExecuteReaderAndReturnRows(command);
                return(this.GetOpenUrlCitationList(list));
            }
        }
Ejemplo n.º 34
0
        public static void Save(SqlConnection sqlConnection, SqlTransaction sqlTransaction, PageType pageType)
        {
            SqlConnection  connection  = sqlConnection;
            SqlTransaction transaction = sqlTransaction;

            if (connection == null)
            {
                connection =
                    CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"));
            }

            bool isTransactionCoordinator = CustomSqlHelper.IsTransactionCoordinator(transaction);

            try
            {
                transaction = CustomSqlHelper.BeginTransaction(connection, transaction, isTransactionCoordinator);

                new PageTypeDAL().PageTypeManageAuto(connection, transaction, pageType);

                CustomSqlHelper.CommitTransaction(transaction, isTransactionCoordinator);
            }
            catch (Exception ex)
            {
                CustomSqlHelper.RollbackTransaction(transaction, isTransactionCoordinator);

                throw new Exception("Exception in Save", ex);
            }
            finally
            {
                CustomSqlHelper.CloseConnection(connection, isTransactionCoordinator);
            }
        }
Ejemplo n.º 35
0
        /// <summary>
        /// Select values from PageSummaryView by Item and Sequence
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <param name="itemID"></param>
        /// <param name="sequence"></param>
        /// <returns>Object of type Title.</returns>
        public PageSummaryView PageSummarySelectByItemAndSequence(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            int itemID,
            int sequence)
        {
            SqlConnection  connection  = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("PageSummarySelectByItemAndSequence", connection, transaction,
                                                                      CustomSqlHelper.CreateInputParameter("ItemID", SqlDbType.Int, null, false, itemID),
                                                                      CustomSqlHelper.CreateInputParameter("Sequence", SqlDbType.Int, null, false, sequence)))
            {
                using (CustomSqlHelper <PageSummaryView> helper = new CustomSqlHelper <PageSummaryView>())
                {
                    CustomGenericList <PageSummaryView> list = helper.ExecuteReader(command);
                    if (list.Count > 0)
                    {
                        return(list[0]);
                    }
                    else
                    {
                        return(null);
                    }
                }
            }
        }
Ejemplo n.º 36
0
        public static Item ItemSelectByBarCodeOrItemID( SqlConnection sqlConnection, SqlTransaction sqlTransaction,
            int? itemId, string barCode)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(
                CustomSqlHelper.GetConnectionStringFromConnectionStrings( "BHL" ), sqlConnection );
            SqlTransaction transaction = sqlTransaction;

            using ( SqlCommand command = CustomSqlHelper.CreateCommand( "ItemSelectByBarCodeOrItemID", connection, transaction,
                CustomSqlHelper.CreateInputParameter( "ItemID", SqlDbType.Int, null, true, itemId ),
                CustomSqlHelper.CreateInputParameter( "BarCode", SqlDbType.NVarChar, 40, true, barCode ) ) )
            {
                using ( CustomSqlHelper<Item> helper = new CustomSqlHelper<Item>() )
                {
                    CustomGenericList<Item> list = helper.ExecuteReader( command );
                    if ( list.Count > 0 )
                    {
                        Item item = (Item)list[ 0 ];
                        item.Pages = new PageDAL().PageSelectByItemID( connection, transaction, item.ItemID );
                        //item.Titles = new TitleDAL().TitleSelectByItem(connection, transaction, item.ItemID);
                        item.TitleItems = new TitleItemDAL().TitleItemSelectByItem(connection, transaction, item.ItemID);
                        item.ItemLanguages = new ItemLanguageDAL().ItemLanguageSelectByItemID(connection, transaction, item.ItemID);
                        return item;
                    }
                    else
                    {
                        return null;
                    }
                }
            }
        }
Ejemplo n.º 37
0
        public CustomGenericList<MonthlyStats> MonthlyStatsSelectCurrentYearSummary(SqlConnection sqlConnection, SqlTransaction sqlTransaction)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("MonthlyStatsSelectCurrentYearSummary", connection, transaction))
            {
                using (CustomSqlHelper<MonthlyStats> helper = new CustomSqlHelper<MonthlyStats>())
                {
                    CustomGenericList<MonthlyStats> list = helper.ExecuteReader(command);
                    return (list);
                }
            }
        }
Ejemplo n.º 38
0
 public static CustomGenericList<ItemStatus> SelectAll( SqlConnection sqlConnection, SqlTransaction sqlTransaction )
 {
     SqlConnection connection = CustomSqlHelper.CreateConnection(
         CustomSqlHelper.GetConnectionStringFromConnectionStrings( "BHL" ), sqlConnection );
     SqlTransaction transaction = sqlTransaction;
     using ( SqlCommand command = CustomSqlHelper.CreateCommand( "ItemStatusSelectAll", connection, transaction ) )
     {
         using ( CustomSqlHelper<ItemStatus> helper = new CustomSqlHelper<ItemStatus>() )
         {
             CustomGenericList<ItemStatus> list = helper.ExecuteReader( command );
             return ( list );
         }
     }
 }
Ejemplo n.º 39
0
        public CustomGenericList<Location> LocationSelectAllValid(SqlConnection sqlConnection, SqlTransaction sqlTransaction)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("LocationSelectAllValid", connection, transaction))
            {
                using (CustomSqlHelper<Location> helper = new CustomSqlHelper<Location>())
                {
                    CustomGenericList<Location> list = helper.ExecuteReader(command);
                    return (list);
                }
            }
        }
Ejemplo n.º 40
0
 public CustomGenericList<Language> LanguageSelectWithPublishedItems(
     SqlConnection sqlConnection,
     SqlTransaction sqlTransaction)
 {
     SqlConnection connection = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
     SqlTransaction transaction = sqlTransaction;
     using (SqlCommand command = CustomSqlHelper.CreateCommand("LanguageSelectWithPublishedItems", connection, transaction))
     {
         using (CustomSqlHelper<Language> helper = new CustomSqlHelper<Language>())
         {
             CustomGenericList<Language> list = helper.ExecuteReader(command);
             return (list);
         }
     }
 }
Ejemplo n.º 41
0
        public CustomGenericList<Location> LocationSelectValidByInstitution(SqlConnection sqlConnection, SqlTransaction sqlTransaction, string institutionCode, string languageCode)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("LocationSelectValidByInstitution", connection, transaction,
                CustomSqlHelper.CreateInputParameter("InstitutionCode", SqlDbType.NVarChar, 10, false, institutionCode),
                CustomSqlHelper.CreateInputParameter("LanguageCode", SqlDbType.NVarChar, 10, false, languageCode)))
            {
                using (CustomSqlHelper<Location> helper = new CustomSqlHelper<Location>())
                {
                    CustomGenericList<Location> list = helper.ExecuteReader(command);
                    return (list);
                }
            }
        }
Ejemplo n.º 42
0
        public CustomGenericList<PageSummaryView> PDFPageSummaryViewSelectByPdfID(SqlConnection sqlConnection, SqlTransaction sqlTransaction,
            int PdfId)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("PDFPageSummaryViewSelectByPdfId", connection, transaction,
                CustomSqlHelper.CreateInputParameter("PdfID", SqlDbType.Int, null, false, PdfId)))
            {
                using (CustomSqlHelper<PageSummaryView> helper = new CustomSqlHelper<PageSummaryView>())
                {
                    CustomGenericList<PageSummaryView> list = helper.ExecuteReader(command);
                    return list;
                }
            }
        }
Ejemplo n.º 43
0
        public static CustomGenericList<CreatorRoleType> CreatorRoleTypeSelectAll( SqlConnection sqlConnection, 
            SqlTransaction sqlTransaction)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(
                CustomSqlHelper.GetConnectionStringFromConnectionStrings( "BHL" ), sqlConnection );
            SqlTransaction transaction = sqlTransaction;

            using ( SqlCommand command = CustomSqlHelper.CreateCommand( "CreatorRoleTypeSelectAll", connection, transaction ) )
            {
                using ( CustomSqlHelper<CreatorRoleType> helper = new CustomSqlHelper<CreatorRoleType>() )
                {
                    CustomGenericList<CreatorRoleType> list = helper.ExecuteReader( command );
                    return list;
                }
            }
        }
Ejemplo n.º 44
0
        public static CustomGenericList<NameCloud> PageNameSelectTop(SqlConnection sqlConnection,
            SqlTransaction sqlTransaction, int top)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(
                CustomSqlHelper.GetConnectionStringFromConnectionStrings( "BHL" ), sqlConnection );
            SqlTransaction transaction = sqlTransaction;

            using ( SqlCommand command = CustomSqlHelper.CreateCommand( "PageNameSelectTop", connection, transaction,
                CustomSqlHelper.CreateInputParameter( "Number", SqlDbType.Int, null, false, top ) ) )
            {
                using ( CustomSqlHelper<NameCloud> helper = new CustomSqlHelper<NameCloud>() )
                {
                    return helper.ExecuteReader( command );
                }
            }
        }
Ejemplo n.º 45
0
        public CustomGenericList<ItemLanguage> ItemLanguageSelectByItemID(SqlConnection sqlConnection,
            SqlTransaction sqlTransaction, int itemId)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(
                CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("ItemLanguageSelectByItemID", connection, transaction,
                            CustomSqlHelper.CreateInputParameter("ItemID", SqlDbType.Int, null, false, itemId)))
            {
                using (CustomSqlHelper<ItemLanguage> helper = new CustomSqlHelper<ItemLanguage>())
                {
                    CustomGenericList<ItemLanguage> list = helper.ExecuteReader(command);
                    return list;
                }
            }
        }
Ejemplo n.º 46
0
        public static CustomGenericList<Title_Creator> Title_CreatorSelectByTitle( SqlConnection sqlConnection,
            SqlTransaction sqlTransaction, int titleID)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(
                CustomSqlHelper.GetConnectionStringFromConnectionStrings( "BHL" ), sqlConnection );
            SqlTransaction transaction = sqlTransaction;

            using ( SqlCommand command = CustomSqlHelper.CreateCommand( "Title_CreatorSelectByTitle", connection, transaction,
                    CustomSqlHelper.CreateInputParameter( "TitleID", SqlDbType.Int, null, false, titleID ) ) )
            {
                using ( CustomSqlHelper<Title_Creator> helper = new CustomSqlHelper<Title_Creator>() )
                {
                    CustomGenericList<Title_Creator> list = helper.ExecuteReader( command );
                    return list;
                }
            }
        }
Ejemplo n.º 47
0
        // This does not filter on item status
        public static CustomGenericList<Item> ItemSelectByMarcBibId( SqlConnection sqlConnection,	SqlTransaction sqlTransaction,
            string marcBibId)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(
                CustomSqlHelper.GetConnectionStringFromConnectionStrings( "BHL" ), sqlConnection );
            SqlTransaction transaction = sqlTransaction;

            using ( SqlCommand command = CustomSqlHelper.CreateCommand( "ItemSelectByMARCBibID", connection, transaction,
                    CustomSqlHelper.CreateInputParameter( "MARCBibID", SqlDbType.NVarChar, 50, false, marcBibId) ) )
            {
                using ( CustomSqlHelper<Item> helper = new CustomSqlHelper<Item>() )
                {
                    CustomGenericList<Item> list = helper.ExecuteReader( command );
                    return ( list );
                }
            }
        }
Ejemplo n.º 48
0
        public CustomGenericList<MonthlyStats> MonthlyStatsSelectByStatType(SqlConnection sqlConnection, SqlTransaction sqlTransaction, 
            string statType, string institutionName, bool showMonthly)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("MonthlyStatsSelectByStatType", connection, transaction,
                CustomSqlHelper.CreateInputParameter("StatType", SqlDbType.NVarChar, 100, false, statType),
                CustomSqlHelper.CreateInputParameter("InstitutionName", SqlDbType.NVarChar, 255, false, institutionName),
                CustomSqlHelper.CreateInputParameter("ShowMonthly", SqlDbType.Bit, null, false, showMonthly)))
            {
                using (CustomSqlHelper<MonthlyStats> helper = new CustomSqlHelper<MonthlyStats>())
                {
                    CustomGenericList<MonthlyStats> list = helper.ExecuteReader(command);
                    return (list);
                }
            }
        }
Ejemplo n.º 49
0
        public Page PageMetadataSelectByPageID( SqlConnection sqlConnection, SqlTransaction sqlTransaction, int pageID )
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection( CustomSqlHelper.GetConnectionStringFromConnectionStrings( "BHL" ), sqlConnection );
            SqlTransaction transaction = sqlTransaction;

            using ( SqlCommand command = CustomSqlHelper.CreateCommand( "PageMetadataSelectByPageID", connection, transaction,
                    CustomSqlHelper.CreateInputParameter( "PageID", SqlDbType.Int, null, false, pageID ) ) )
            {
                using ( CustomSqlHelper<Page> helper = new CustomSqlHelper<Page>() )
                {
                    CustomGenericList<Page> list = helper.ExecuteReader( command );
                    if ( list.Count > 0 )
                        return list[ 0 ];
                    else
                        return null;
                }
            }
        }
Ejemplo n.º 50
0
        public static void Save( SqlConnection sqlConnection, SqlTransaction sqlTransaction, Vault vault )
        {
            SqlConnection connection = sqlConnection;
            SqlTransaction transaction = sqlTransaction;

            if ( connection == null )
            {
                connection =
                    CustomSqlHelper.CreateConnection( CustomSqlHelper.GetConnectionStringFromConnectionStrings( "BHL" ) );
            }

            bool isTransactionCoordinator = CustomSqlHelper.IsTransactionCoordinator( transaction );

            try
            {
                transaction = CustomSqlHelper.BeginTransaction( connection, transaction, isTransactionCoordinator );

                if ( vault.VaultID == 0 )
                {
                    using ( SqlCommand command = CustomSqlHelper.CreateCommand( "VaultSelectMaxID", connection, transaction ) )
                    {
                        using ( CustomSqlHelper<int> helper = new CustomSqlHelper<int>() )
                        {
                            CustomGenericList<int> list = helper.ExecuteReader( command );
                            vault.VaultID = list[ 0 ] + 1;
                        }
                    }
                }

                new VaultDAL().VaultManageAuto( connection, transaction, vault );

                CustomSqlHelper.CommitTransaction( transaction, isTransactionCoordinator );
            }
            catch ( Exception ex )
            {
                CustomSqlHelper.RollbackTransaction( transaction, isTransactionCoordinator );

                throw new Exception( "Exception in Save", ex );
            }
            finally
            {
                CustomSqlHelper.CloseConnection( connection, isTransactionCoordinator );
            }
        }
Ejemplo n.º 51
0
        public CustomGenericList<Title_Creator> MarcSelectCreatorsByMarcID(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            int marcId)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(
            CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("MarcSelectCreatorsByMarcID", connection, transaction,
                CustomSqlHelper.CreateInputParameter("MarcID", SqlDbType.Int, null, false, marcId)))
            {
                using (CustomSqlHelper<Title_Creator> helper = new CustomSqlHelper<Title_Creator>())
                {
                    CustomGenericList<Title_Creator> list = helper.ExecuteReader(command);
                    return (list);
                }
            }
        }
Ejemplo n.º 52
0
        public CustomGenericList<MarcImportBatch> MarcImportBatchSelectStatsByInstitution(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            String institutionCode)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(
            CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("MarcImportBatchSelectStatsByInstitution", connection, transaction,
                CustomSqlHelper.CreateInputParameter("InstitutionCode", SqlDbType.NVarChar, 10, false, institutionCode)))
            {
                using (CustomSqlHelper<MarcImportBatch> helper = new CustomSqlHelper<MarcImportBatch>())
                {
                    CustomGenericList<MarcImportBatch> list = helper.ExecuteReader(command);
                    return (list);
                }
            }
        }
Ejemplo n.º 53
0
        public CustomGenericList<MonthlyStats> MonthlyStatsSelectByDateAndInstitution(SqlConnection sqlConnection, SqlTransaction sqlTransaction,
            int startYear, int startMonth, int endYear, int endMonth, String institutionName)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("MonthlyStatsSelectByDateAndInstitution", connection, transaction,
                CustomSqlHelper.CreateInputParameter("StartYear", SqlDbType.Int, null, false, startYear),
                CustomSqlHelper.CreateInputParameter("StartMonth", SqlDbType.Int, null, false, startMonth),
                CustomSqlHelper.CreateInputParameter("EndYear", SqlDbType.Int, null, false, endYear),
                CustomSqlHelper.CreateInputParameter("EndMonth", SqlDbType.Int, null, false, endMonth),
                CustomSqlHelper.CreateInputParameter("InstitutionName", SqlDbType.NVarChar, 255, false, institutionName)))
            {
                using (CustomSqlHelper<MonthlyStats> helper = new CustomSqlHelper<MonthlyStats>())
                {
                    CustomGenericList<MonthlyStats> list = helper.ExecuteReader(command);
                    return (list);
                }
            }
        }
Ejemplo n.º 54
0
        /// <summary>
        /// Select all Items for a particular Title.
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <returns>Object of type Title.</returns>
        public CustomGenericList<TitleAssociation> TitleAssociationSelectByTitleID(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            int titleID,
            bool? active)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(
                CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("TitleAssociationSelectByTitleID", connection, transaction,
                    CustomSqlHelper.CreateInputParameter("TitleID", SqlDbType.Int, null, false, titleID),
                    CustomSqlHelper.CreateInputParameter("Active", SqlDbType.Bit, null, false, active)))
            {
                using (CustomSqlHelper<TitleAssociation> helper = new CustomSqlHelper<TitleAssociation>())
                {
                    CustomGenericList<TitleAssociation> list = helper.ExecuteReader(command);
                    return (list);
                }
            }
        }
        public Title_TitleIdentifier Title_TitleIdentifierSelectByIdentifierValue(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            string identifierValue)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(
                CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("Title_TitleIdentifierSelectByIdentifierValue", connection, transaction,
                CustomSqlHelper.CreateInputParameter("IdentifierValue", SqlDbType.NVarChar, 125, false, identifierValue)))
            {
                using (CustomSqlHelper<Title_TitleIdentifier> helper = new CustomSqlHelper<Title_TitleIdentifier>())
                {
                    CustomGenericList<Title_TitleIdentifier> list = helper.ExecuteReader(command);
                    if (list.Count > 0)
                        return list[0];
                    else
                        return null;
                }
            }
        }
Ejemplo n.º 56
0
        public static Configuration ConfigurationSelectByName(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            String configurationName)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(
              CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("ConfigurationSelectByName", connection, transaction,
                CustomSqlHelper.CreateInputParameter("ConfigurationName", SqlDbType.NVarChar, 50, false, configurationName)))
            {
                using (CustomSqlHelper<Configuration> helper = new CustomSqlHelper<Configuration>())
                {
                    CustomGenericList<Configuration> list = helper.ExecuteReader(command);
                    if (list.Count > 0)
                        return list[0];
                    else
                        return null;
                }
            }
        }
Ejemplo n.º 57
0
        public static CustomGenericList<TitleTag> TitleTagSelectLikeTag( SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            string tag,
            string languageCode,
            string includeSecondaryTitles,
            int returnCount)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(
                CustomSqlHelper.GetConnectionStringFromConnectionStrings( "BHL" ), sqlConnection );
            SqlTransaction transaction = sqlTransaction;

            using ( SqlCommand command = CustomSqlHelper.CreateCommand( "TitleTagSelectLikeTag", connection, transaction,
                    CustomSqlHelper.CreateInputParameter( "TagText", SqlDbType.NVarChar, 50, false, tag ),
                    CustomSqlHelper.CreateInputParameter( "LanguageCode", SqlDbType.NVarChar, 10, false, languageCode),
                    CustomSqlHelper.CreateInputParameter("IncludeSecondaryTitles", SqlDbType.Char, 1, false, includeSecondaryTitles),
                    CustomSqlHelper.CreateInputParameter("ReturnCount", SqlDbType.Int, null, false, returnCount)))
            {
                using ( CustomSqlHelper<TitleTag> helper = new CustomSqlHelper<TitleTag>() )
                {
                    CustomGenericList<TitleTag> list = helper.ExecuteReader( command );
                    return list;
                }
            }
        }
Ejemplo n.º 58
0
        public ItemCOinSView ItemCOinSSelectByTitleId(SqlConnection sqlConnection, SqlTransaction sqlTransaction,
            int titleId)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(
              CustomSqlHelper.GetConnectionStringFromConnectionStrings("BHL"), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("ItemCOinSSelectByTitleId", connection, transaction,
                CustomSqlHelper.CreateInputParameter("TitleID", SqlDbType.Int, null, false, titleId)))
            {
                using (CustomSqlHelper<ItemCOinSView> helper = new CustomSqlHelper<ItemCOinSView>())
                {
                    CustomGenericList<ItemCOinSView> list = helper.ExecuteReader(command);
                    if (list.Count > 0)
                    {
                        return list[0];
                    }
                    else
                    {
                        return null;
                    }
                }
            }
        }
Ejemplo n.º 59
0
        /// <summary>
        /// Update values in Item. Returns an object of type Item.
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <param name="connectionKeyName">Connection key name located in config file.</param>
        /// <param name="itemID"></param>
        /// <param name="primaryTitleID"></param>
        /// <param name="barCode"></param>
        /// <param name="mARCItemID"></param>
        /// <param name="callNumber"></param>
        /// <param name="volume"></param>
        /// <param name="institutionCode"></param>
        /// <param name="languageCode"></param>
        /// <param name="sponsor"></param>
        /// <param name="itemDescription"></param>
        /// <param name="scannedBy"></param>
        /// <param name="pDFSize"></param>
        /// <param name="vaultID"></param>
        /// <param name="numberOfFiles"></param>
        /// <param name="note"></param>
        /// <param name="lastModifiedUserID"></param>
        /// <param name="itemStatusID"></param>
        /// <param name="scanningUser"></param>
        /// <param name="scanningDate"></param>
        /// <param name="paginationCompleteUserID"></param>
        /// <param name="paginationCompleteDate"></param>
        /// <param name="paginationStatusID"></param>
        /// <param name="paginationStatusUserID"></param>
        /// <param name="paginationStatusDate"></param>
        /// <param name="lastPageNameLookupDate"></param>
        /// <param name="itemSourceID"></param>
        /// <param name="year"></param>
        /// <param name="identifierBib"></param>
        /// <param name="fileRootFolder"></param>
        /// <param name="zQuery"></param>
        /// <param name="licenseUrl"></param>
        /// <param name="rights"></param>
        /// <param name="dueDiligence"></param>
        /// <param name="copyrightStatus"></param>
        /// <param name="copyrightRegion"></param>
        /// <param name="copyrightComment"></param>
        /// <param name="copyrightEvidence"></param>
        /// <param name="copyrightEvidenceOperator"></param>
        /// <param name="copyrightEvidenceDate"></param>
        /// <returns>Object of type Item.</returns>
        public Item ItemUpdateAuto(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            string connectionKeyName,
            int itemID,
            int primaryTitleID,
            string barCode,
            string mARCItemID,
            string callNumber,
            string volume,
            string institutionCode,
            string languageCode,
            string sponsor,
            string itemDescription,
            int? scannedBy,
            int? pDFSize,
            int? vaultID,
            short? numberOfFiles,
            string note,
            int? lastModifiedUserID,
            int itemStatusID,
            string scanningUser,
            DateTime? scanningDate,
            int? paginationCompleteUserID,
            DateTime? paginationCompleteDate,
            int? paginationStatusID,
            int? paginationStatusUserID,
            DateTime? paginationStatusDate,
            DateTime? lastPageNameLookupDate,
            int? itemSourceID,
            string year,
            string identifierBib,
            string fileRootFolder,
            string zQuery,
            string licenseUrl,
            string rights,
            string dueDiligence,
            string copyrightStatus,
            string copyrightRegion,
            string copyrightComment,
            string copyrightEvidence,
            string copyrightEvidenceOperator,
            string copyrightEvidenceDate)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings(connectionKeyName), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("ItemUpdateAuto", connection, transaction,
                CustomSqlHelper.CreateInputParameter("ItemID", SqlDbType.Int, null, false, itemID),
                    CustomSqlHelper.CreateInputParameter("PrimaryTitleID", SqlDbType.Int, null, false, primaryTitleID),
                    CustomSqlHelper.CreateInputParameter("BarCode", SqlDbType.NVarChar, 40, false, barCode),
                    CustomSqlHelper.CreateInputParameter("MARCItemID", SqlDbType.NVarChar, 50, true, mARCItemID),
                    CustomSqlHelper.CreateInputParameter("CallNumber", SqlDbType.NVarChar, 100, true, callNumber),
                    CustomSqlHelper.CreateInputParameter("Volume", SqlDbType.NVarChar, 100, true, volume),
                    CustomSqlHelper.CreateInputParameter("InstitutionCode", SqlDbType.NVarChar, 10, true, institutionCode),
                    CustomSqlHelper.CreateInputParameter("LanguageCode", SqlDbType.NVarChar, 10, true, languageCode),
                    CustomSqlHelper.CreateInputParameter("Sponsor", SqlDbType.NVarChar, 100, true, sponsor),
                    CustomSqlHelper.CreateInputParameter("ItemDescription", SqlDbType.NText, 1073741823, true, itemDescription),
                    CustomSqlHelper.CreateInputParameter("ScannedBy", SqlDbType.Int, null, true, scannedBy),
                    CustomSqlHelper.CreateInputParameter("PDFSize", SqlDbType.Int, null, true, pDFSize),
                    CustomSqlHelper.CreateInputParameter("VaultID", SqlDbType.Int, null, true, vaultID),
                    CustomSqlHelper.CreateInputParameter("NumberOfFiles", SqlDbType.SmallInt, null, true, numberOfFiles),
                    CustomSqlHelper.CreateInputParameter("Note", SqlDbType.NVarChar, 255, true, note),
                    CustomSqlHelper.CreateInputParameter("LastModifiedUserID", SqlDbType.Int, null, true, lastModifiedUserID),
                    CustomSqlHelper.CreateInputParameter("ItemStatusID", SqlDbType.Int, null, false, itemStatusID),
                    CustomSqlHelper.CreateInputParameter("ScanningUser", SqlDbType.NVarChar, 100, true, scanningUser),
                    CustomSqlHelper.CreateInputParameter("ScanningDate", SqlDbType.DateTime, null, true, scanningDate),
                    CustomSqlHelper.CreateInputParameter("PaginationCompleteUserID", SqlDbType.Int, null, true, paginationCompleteUserID),
                    CustomSqlHelper.CreateInputParameter("PaginationCompleteDate", SqlDbType.DateTime, null, true, paginationCompleteDate),
                    CustomSqlHelper.CreateInputParameter("PaginationStatusID", SqlDbType.Int, null, true, paginationStatusID),
                    CustomSqlHelper.CreateInputParameter("PaginationStatusUserID", SqlDbType.Int, null, true, paginationStatusUserID),
                    CustomSqlHelper.CreateInputParameter("PaginationStatusDate", SqlDbType.DateTime, null, true, paginationStatusDate),
                    CustomSqlHelper.CreateInputParameter("LastPageNameLookupDate", SqlDbType.DateTime, null, true, lastPageNameLookupDate),
                    CustomSqlHelper.CreateInputParameter("ItemSourceID", SqlDbType.Int, null, true, itemSourceID),
                    CustomSqlHelper.CreateInputParameter("Year", SqlDbType.NVarChar, 20, true, year),
                    CustomSqlHelper.CreateInputParameter("IdentifierBib", SqlDbType.NVarChar, 50, true, identifierBib),
                    CustomSqlHelper.CreateInputParameter("FileRootFolder", SqlDbType.NVarChar, 250, true, fileRootFolder),
                    CustomSqlHelper.CreateInputParameter("ZQuery", SqlDbType.NVarChar, 200, true, zQuery),
                    CustomSqlHelper.CreateInputParameter("LicenseUrl", SqlDbType.NVarChar, 1073741823, true, licenseUrl),
                    CustomSqlHelper.CreateInputParameter("Rights", SqlDbType.NVarChar, 1073741823, true, rights),
                    CustomSqlHelper.CreateInputParameter("DueDiligence", SqlDbType.NVarChar, 1073741823, true, dueDiligence),
                    CustomSqlHelper.CreateInputParameter("CopyrightStatus", SqlDbType.NVarChar, 1073741823, true, copyrightStatus),
                    CustomSqlHelper.CreateInputParameter("CopyrightRegion", SqlDbType.NVarChar, 50, true, copyrightRegion),
                    CustomSqlHelper.CreateInputParameter("CopyrightComment", SqlDbType.NVarChar, 1073741823, true, copyrightComment),
                    CustomSqlHelper.CreateInputParameter("CopyrightEvidence", SqlDbType.NVarChar, 1073741823, true, copyrightEvidence),
                    CustomSqlHelper.CreateInputParameter("CopyrightEvidenceOperator", SqlDbType.NVarChar, 100, true, copyrightEvidenceOperator),
                    CustomSqlHelper.CreateInputParameter("CopyrightEvidenceDate", SqlDbType.NVarChar, 30, true, copyrightEvidenceDate),
                    CustomSqlHelper.CreateReturnValueParameter("ReturnCode", SqlDbType.Int, null, false)))
            {
                using (CustomSqlHelper<Item> helper = new CustomSqlHelper<Item>())
                {
                    CustomGenericList<Item> list = helper.ExecuteReader(command);
                    if (list.Count > 0)
                    {
                        Item o = list[0];
                        list = null;
                        return o;
                    }
                    else
                    {
                        return null;
                    }
                }
            }
        }
Ejemplo n.º 60
0
        /// <summary>
        /// Update values in PDFPage. Returns an object of type PDFPage.
        /// </summary>
        /// <param name="sqlConnection">Sql connection or null.</param>
        /// <param name="sqlTransaction">Sql transaction or null.</param>
        /// <param name="connectionKeyName">Connection key name located in config file.</param>
        /// <param name="pdfPageID"></param>
        /// <param name="pdfID"></param>
        /// <param name="pageID"></param>
        /// <returns>Object of type PDFPage.</returns>
        public PDFPage PDFPageUpdateAuto(
            SqlConnection sqlConnection,
            SqlTransaction sqlTransaction,
            string connectionKeyName,
            int pdfPageID,
            int pdfID,
            int pageID)
        {
            SqlConnection connection = CustomSqlHelper.CreateConnection(CustomSqlHelper.GetConnectionStringFromConnectionStrings(connectionKeyName), sqlConnection);
            SqlTransaction transaction = sqlTransaction;

            using (SqlCommand command = CustomSqlHelper.CreateCommand("PDFPageUpdateAuto", connection, transaction,
                CustomSqlHelper.CreateInputParameter("PdfPageID", SqlDbType.Int, null, false, pdfPageID),
                    CustomSqlHelper.CreateInputParameter("PdfID", SqlDbType.Int, null, false, pdfID),
                    CustomSqlHelper.CreateInputParameter("PageID", SqlDbType.Int, null, false, pageID),
                    CustomSqlHelper.CreateReturnValueParameter("ReturnCode", SqlDbType.Int, null, false)))
            {
                using (CustomSqlHelper<PDFPage> helper = new CustomSqlHelper<PDFPage>())
                {
                    CustomGenericList<PDFPage> list = helper.ExecuteReader(command);
                    if (list.Count > 0)
                    {
                        PDFPage o = list[0];
                        list = null;
                        return o;
                    }
                    else
                    {
                        return null;
                    }
                }
            }
        }