예제 #1
0
        public void UpdateCustomerIntegrationTest()
        {
            string returnMessage;

            TransactionalInformation transaction;

            CustomerApplicationService customerApplicationService = new CustomerApplicationService(customerDataService);

            DataGridPagingInformation paging = new DataGridPagingInformation();

            paging.CurrentPageNumber = 1;
            paging.PageSize          = 15;
            paging.SortExpression    = "LastName";
            paging.SortDirection     = "ASC";

            List <CustomerInquiry> customers = customerApplicationService.CustomerInquiry("", "", paging, out transaction);

            var  customerInformation = (from c in customers select c).First();
            Guid customerID          = customerInformation.CustomerID;

            Customer customer = customerApplicationService.GetCustomerByCustomerID(customerID, out transaction);

            customerApplicationService.UpdateCustomer(customer, out transaction);
            returnMessage = Utilities.GetReturnMessage(transaction.ReturnMessage);

            Assert.AreEqual(true, transaction.ReturnStatus, returnMessage);
        }
        /// <summary>
        /// product Inquiry
        /// </summary>
        /// <param name="productCode"></param>
        /// <param name="companyName"></param>
        /// <param name="paging"></param>
        /// <param name="transaction"></param>
        /// <returns></returns>
        public List <Product> ProductInquiry(string productCode, string description, DataGridPagingInformation paging, out TransactionalInformation transaction)
        {
            transaction = new TransactionalInformation();

            List <Product> products = new List <Product>();

            try
            {
                productsDataService.CreateSession();
                products = productsDataService.ProductInquiry(productCode, description, paging, out transaction);
            }
            catch (Exception ex)
            {
                transaction.ReturnMessage = new List <string>();
                string errorMessage = ex.Message;
                transaction.ReturnStatus = false;
                transaction.ReturnMessage.Add(errorMessage);
            }
            finally
            {
                productsDataService.CloseSession();
            }

            return(products);
        }
        public List <tkey> APIInquiry(string exchange, string apiKey, DataGridPagingInformation paging, out TransactionalInformation transaction)
        {
            transaction = new TransactionalInformation();

            List <tkey> keyList = new List <tkey>();

            try
            {
                APIDataService.CreateSession();
                keyList = APIDataService.APIInquiry(exchange, apiKey, paging, out transaction);
            }
            catch (Exception ex)
            {
                transaction.ReturnMessage = new List <string>();
                string errorMessage = ex.Message;
                transaction.ReturnStatus = false;
                transaction.ReturnMessage.Add(errorMessage);
            }
            finally
            {
                APIDataService.CloseSession();
            }

            return(keyList);
        }
        public List <ttrade> TradeInquiry(string OrderID, string OrderStatus, DataGridPagingInformation paging, out TransactionalInformation transaction)
        {
            transaction = new TransactionalInformation();

            List <ttrade> tradeList = new List <ttrade>();

            try
            {
                tradesDataService.CreateSession();
                tradeList = tradesDataService.TradeInquiry(OrderID, OrderStatus, paging, out transaction);
            }
            catch (Exception ex)
            {
                transaction.ReturnMessage = new List <string>();
                string errorMessage = ex.Message;
                transaction.ReturnStatus = false;
                transaction.ReturnMessage.Add(errorMessage);
            }
            finally
            {
                tradesDataService.CloseSession();
            }

            return(tradeList);
        }
예제 #5
0
        public List <contact> ContactInquiry(string firstName, string lastName, DataGridPagingInformation paging, out TransactionalInformation transaction)
        {
            transaction = new TransactionalInformation();

            List <contact> contactList = new List <contact>();

            try
            {
                ContactsDataService.CreateSession();
                contactList = ContactsDataService.ContactInquiry(firstName, lastName, paging, out transaction);
            }
            catch (Exception ex)
            {
                transaction.ReturnMessage = new List <string>();
                string errorMessage = ex.Message;
                transaction.ReturnStatus = false;
                transaction.ReturnMessage.Add(errorMessage);
            }
            finally
            {
                ContactsDataService.CloseSession();
            }

            return(contactList);
        }
        /// <summary>
        /// Product Inquiry
        /// </summary>
        /// <param name="productCode"></param>
        /// <param name="description"></param>
        /// <param name="paging"></param>
        /// <param name="transaction"></param>
        /// <returns></returns>
        public List <Product> ProductInquiry(string productCode, string description, DataGridPagingInformation paging, out TransactionalInformation transaction)
        {
            transaction = new TransactionalInformation();

            string sortExpression = paging.SortExpression;

            if (paging.SortDirection != string.Empty)
            {
                sortExpression = sortExpression + " " + paging.SortDirection;
            }

            List <Product> productInquiry = new List <Product>();

            int numberOfRows = 0;

            var productQuery = dbConnection.Products.AsQueryable();

            if (productCode != null && productCode.Trim().Length > 0)
            {
                productQuery = productQuery.Where(c => c.ProductCode.StartsWith(productCode));
            }

            if (description != null && description.Trim().Length > 0)
            {
                productQuery = productQuery.Where(c => c.Description.StartsWith(description));
            }

            var products = from p in productQuery
                           select new { p.ProductID, p.ProductCode, p.Description, p.UnitPrice, p.UnitOfMeasure };

            numberOfRows = products.Count();

            products = products.OrderBy(sortExpression);

            var productList = products.Skip((paging.CurrentPageNumber - 1) * paging.PageSize).Take(paging.PageSize);

            paging.TotalRows  = numberOfRows;
            paging.TotalPages = AngularJSUtilities.Utilities.CalculateTotalPages(numberOfRows, paging.PageSize);

            foreach (var product in productList)
            {
                Product productData = new Product();
                productData.ProductID     = product.ProductID;
                productData.ProductCode   = product.ProductCode;
                productData.Description   = product.Description;
                productData.UnitOfMeasure = product.UnitOfMeasure;
                productData.UnitPrice     = product.UnitPrice;

                productInquiry.Add(productData);
            }


            transaction.TotalPages   = paging.TotalPages;
            transaction.TotalRows    = paging.TotalRows;
            transaction.ReturnStatus = true;
            transaction.ReturnMessage.Add(numberOfRows.ToString() + " product records found.");

            return(productInquiry);
        }
        public HttpResponseMessage CustomerInquiry(string FirstName, string LastName, int CurrentPageNumber, string SortExpression, string SortDirection, int PageSize)
        {
            TransactionalInformation transaction;

            if (FirstName == null)
            {
                FirstName = string.Empty;
            }
            if (LastName == null)
            {
                LastName = string.Empty;
            }
            if (SortDirection == null)
            {
                SortDirection = string.Empty;
            }
            if (SortExpression == null)
            {
                SortExpression = string.Empty;
            }

            CustomerInquiryViewModel customerInquiryViewModel = new CustomerInquiryViewModel();

            DataGridPagingInformation paging = new DataGridPagingInformation();

            paging.CurrentPageNumber = CurrentPageNumber;
            paging.PageSize          = PageSize;
            paging.SortExpression    = SortExpression;
            paging.SortDirection     = SortDirection;

            if (paging.SortDirection == "")
            {
                paging.SortDirection = "ASC";
            }
            if (paging.SortExpression == "")
            {
                paging.SortExpression = "LastName";
            }

            CustomerApplicationService customerApplicationService = new CustomerApplicationService(customerDataService);
            List <CustomerInquiry>     customers = customerApplicationService.CustomerInquiry(FirstName, LastName, paging, out transaction);

            customerInquiryViewModel.Customers     = customers;
            customerInquiryViewModel.ReturnStatus  = transaction.ReturnStatus;
            customerInquiryViewModel.ReturnMessage = transaction.ReturnMessage;
            customerInquiryViewModel.TotalPages    = paging.TotalPages;
            customerInquiryViewModel.TotalRows     = paging.TotalRows;
            customerInquiryViewModel.PageSize      = paging.PageSize;

            if (transaction.ReturnStatus == true)
            {
                var response = Request.CreateResponse <CustomerInquiryViewModel>(HttpStatusCode.OK, customerInquiryViewModel);
                return(response);
            }

            var badResponse = Request.CreateResponse <CustomerInquiryViewModel>(HttpStatusCode.BadRequest, customerInquiryViewModel);

            return(badResponse);
        }
예제 #8
0
        /// <summary>
        /// Purchase Order Inquiry
        /// </summary>
        /// <param name="accountId"></param>
        /// <param name="supplierName"></param>
        /// <param name="currentPageNumber"></param>
        /// <param name="pageSize"></param>
        /// <param name="sortExpression"></param>
        /// <param name="sortDirection"></param>
        /// <returns></returns>
        public async Task <ResponseModel <List <PurchaseOrderDataTransformation> > > PurchaseOrderInquiry(int accountId, string supplierName, int currentPageNumber, int pageSize, string sortExpression, string sortDirection)
        {
            ResponseModel <List <PurchaseOrderDataTransformation> > returnResponse = new ResponseModel <List <PurchaseOrderDataTransformation> >();

            List <PurchaseOrderDataTransformation> purchaseOrders = new List <PurchaseOrderDataTransformation>();

            try
            {
                _purchaseOrderManagementDataService.OpenConnection(_connectionStrings.PrimaryDatabaseConnectionString);

                DataGridPagingInformation dataGridPagingInformation = new DataGridPagingInformation();
                dataGridPagingInformation.CurrentPageNumber = currentPageNumber;
                dataGridPagingInformation.PageSize          = pageSize;
                dataGridPagingInformation.SortDirection     = sortDirection;
                dataGridPagingInformation.SortExpression    = sortExpression;

                List <PurchaseOrder> purchaseOrderList = await _purchaseOrderManagementDataService.PurchaseOrderInquiry(accountId, supplierName, dataGridPagingInformation);

                foreach (PurchaseOrder purchaseOrder in purchaseOrderList)
                {
                    PurchaseOrderDataTransformation purchaseOrderDataTransformation = new PurchaseOrderDataTransformation();
                    purchaseOrderDataTransformation.SupplierId                     = purchaseOrder.SupplierId;
                    purchaseOrderDataTransformation.AddressLine1                   = purchaseOrder.Supplier.AddressLine1;
                    purchaseOrderDataTransformation.AddressLine2                   = purchaseOrder.Supplier.AddressLine2;
                    purchaseOrderDataTransformation.City                           = purchaseOrder.Supplier.City;
                    purchaseOrderDataTransformation.Region                         = purchaseOrder.Supplier.Region;
                    purchaseOrderDataTransformation.PostalCode                     = purchaseOrder.Supplier.PostalCode;
                    purchaseOrderDataTransformation.SupplierName                   = purchaseOrder.Supplier.Name;
                    purchaseOrderDataTransformation.DateCreated                    = purchaseOrder.DateCreated;
                    purchaseOrderDataTransformation.OrderTotal                     = purchaseOrder.OrderTotal;
                    purchaseOrderDataTransformation.AccountId                      = purchaseOrder.AccountId;
                    purchaseOrderDataTransformation.PurchaseOrderId                = purchaseOrder.PurchaseOrderId;
                    purchaseOrderDataTransformation.PurchaseOrderNumber            = purchaseOrder.PurchaseOrderNumber;
                    purchaseOrderDataTransformation.PurchaseOrderStatusId          = purchaseOrder.PurchaseOrderStatusId;
                    purchaseOrderDataTransformation.PurchaseOrderStatusDescription = purchaseOrder.PurchaseOrderStatus.Description;
                    purchaseOrders.Add(purchaseOrderDataTransformation);
                }

                returnResponse.Entity     = purchaseOrders;
                returnResponse.TotalRows  = dataGridPagingInformation.TotalRows;
                returnResponse.TotalPages = dataGridPagingInformation.TotalPages;

                returnResponse.ReturnStatus = true;
            }
            catch (Exception ex)
            {
                _purchaseOrderManagementDataService.RollbackTransaction();
                returnResponse.ReturnStatus = false;
                returnResponse.ReturnMessage.Add(ex.Message);
            }
            finally
            {
                _purchaseOrderManagementDataService.CloseConnection();
            }

            return(returnResponse);
        }
        /// <summary>
        /// Sales Order Inquiry
        /// </summary>
        /// <param name="accountId"></param>
        /// <param name="customerName"></param>
        /// <param name="currentPageNumber"></param>
        /// <param name="pageSize"></param>
        /// <param name="sortExpression"></param>
        /// <param name="sortDirection"></param>
        /// <returns></returns>
        public async Task <ResponseModel <List <SalesOrderDataTransformation> > > SalesOrderInquiry(int accountId, string customerName, int currentPageNumber, int pageSize, string sortExpression, string sortDirection)
        {
            ResponseModel <List <SalesOrderDataTransformation> > returnResponse = new ResponseModel <List <SalesOrderDataTransformation> >();

            List <SalesOrderDataTransformation> salesOrders = new List <SalesOrderDataTransformation>();

            try
            {
                _inventoryManagementDataService.OpenConnection(_connectionStrings.PrimaryDatabaseConnectionString);

                DataGridPagingInformation dataGridPagingInformation = new DataGridPagingInformation();
                dataGridPagingInformation.CurrentPageNumber = currentPageNumber;
                dataGridPagingInformation.PageSize          = pageSize;
                dataGridPagingInformation.SortDirection     = sortDirection;
                dataGridPagingInformation.SortExpression    = sortExpression;

                List <SalesOrder> salesOrderList = await _inventoryManagementDataService.SalesOrderInquiry(accountId, customerName, dataGridPagingInformation);

                foreach (SalesOrder salesOrder in salesOrderList)
                {
                    SalesOrderDataTransformation salesOrderDataTransformation = new SalesOrderDataTransformation();
                    salesOrderDataTransformation.AddressLine1                = salesOrder.AddressLine1;
                    salesOrderDataTransformation.AddressLine2                = salesOrder.AddressLine2;
                    salesOrderDataTransformation.City                        = salesOrder.City;
                    salesOrderDataTransformation.Region                      = salesOrder.Region;
                    salesOrderDataTransformation.PostalCode                  = salesOrder.PostalCode;
                    salesOrderDataTransformation.CustomerName                = salesOrder.CustomerName;
                    salesOrderDataTransformation.DateCreated                 = salesOrder.DateCreated;
                    salesOrderDataTransformation.OrderTotal                  = salesOrder.OrderTotal;
                    salesOrderDataTransformation.AccountId                   = salesOrder.AccountId;
                    salesOrderDataTransformation.SalesOrderId                = salesOrder.SalesOrderId;
                    salesOrderDataTransformation.SalesOrderNumber            = salesOrder.SalesOrderNumber;
                    salesOrderDataTransformation.SalesOrderStatusId          = salesOrder.SalesOrderStatusId;
                    salesOrderDataTransformation.SalesOrderStatusDescription = salesOrder.SalesOrderStatus.Description;
                    salesOrders.Add(salesOrderDataTransformation);
                }

                returnResponse.Entity     = salesOrders;
                returnResponse.TotalRows  = dataGridPagingInformation.TotalRows;
                returnResponse.TotalPages = dataGridPagingInformation.TotalPages;

                returnResponse.ReturnStatus = true;
            }
            catch (Exception ex)
            {
                returnResponse.ReturnStatus = false;
                returnResponse.ReturnMessage.Add(ex.Message);
            }
            finally
            {
                _inventoryManagementDataService.CloseConnection();
            }

            return(returnResponse);
        }
        /// <summary>
        /// Product Inquiry
        /// </summary>
        /// <param name="accountId"></param>
        /// <param name="productNumber"></param>
        /// <param name="currentPageNumber"></param>
        /// <param name="pageSize"></param>
        /// <param name="sortExpression"></param>
        /// <param name="sortDirection"></param>
        /// <returns></returns>
        public async Task <ResponseModel <List <ProductDataTransformation> > > ProductInquiry(int accountId, string productNumber, int currentPageNumber, int pageSize, string sortExpression, string sortDirection)
        {
            ResponseModel <List <ProductDataTransformation> > returnResponse = new ResponseModel <List <ProductDataTransformation> >();

            List <ProductDataTransformation> products = new List <ProductDataTransformation>();

            try
            {
                _inventoryManagementDataService.OpenConnection(_connectionStrings.PrimaryDatabaseConnectionString);

                DataGridPagingInformation dataGridPagingInformation = new DataGridPagingInformation();
                dataGridPagingInformation.CurrentPageNumber = currentPageNumber;
                dataGridPagingInformation.PageSize          = pageSize;
                dataGridPagingInformation.SortDirection     = sortDirection;
                dataGridPagingInformation.SortExpression    = sortExpression;

                List <Product> productList = await _inventoryManagementDataService.ProductInquiry(accountId, productNumber, dataGridPagingInformation);

                foreach (Product product in productList)
                {
                    ProductDataTransformation productDataTransformation = new ProductDataTransformation();
                    productDataTransformation.ProductId         = product.ProductId;
                    productDataTransformation.AverageCost       = product.AverageCost;
                    productDataTransformation.BinLocation       = product.BinLocation;
                    productDataTransformation.CommittedQuantity = product.CommittedQuantity;
                    productDataTransformation.DateCreated       = product.DateCreated;
                    productDataTransformation.Description       = product.Description;
                    productDataTransformation.OnHandQuantity    = product.OnHandQuantity;
                    productDataTransformation.OnOrderQuantity   = product.OnOrderQuantity;
                    productDataTransformation.ProductNumber     = product.ProductNumber;
                    productDataTransformation.UnitPrice         = product.UnitPrice;

                    products.Add(productDataTransformation);
                }

                returnResponse.Entity     = products;
                returnResponse.TotalRows  = dataGridPagingInformation.TotalRows;
                returnResponse.TotalPages = dataGridPagingInformation.TotalPages;

                returnResponse.ReturnStatus = true;
            }
            catch (Exception ex)
            {
                _inventoryManagementDataService.RollbackTransaction();
                returnResponse.ReturnStatus = false;
                returnResponse.ReturnMessage.Add(ex.Message);
            }
            finally
            {
                _inventoryManagementDataService.CloseConnection();
            }

            return(returnResponse);
        }
        public async Task <ResponseModel <List <ContactDataTransformation> > > GetContact(int accountId, string searchText, int currentPageNumber, int pageSize, string sortExpression, string sortDirection)
        {
            ResponseModel <List <ContactDataTransformation> > returnResponse = new ResponseModel <List <ContactDataTransformation> >();

            List <ContactDataTransformation> salesOrders = new List <ContactDataTransformation>();

            try
            {
                _contactManagementDataService.OpenConnection(_connectionStrings.PrimaryDatabaseConnectionString);

                DataGridPagingInformation dataGridPagingInformation = new DataGridPagingInformation();
                dataGridPagingInformation.CurrentPageNumber = currentPageNumber;
                dataGridPagingInformation.PageSize          = pageSize;
                dataGridPagingInformation.SortDirection     = sortDirection;
                dataGridPagingInformation.SortExpression    = sortExpression;

                List <Contact> contactsList = await _contactManagementDataService.GetContacts(accountId, searchText, dataGridPagingInformation);

                foreach (Contact contact in contactsList)
                {
                    ContactDataTransformation contactDataTransformation = new ContactDataTransformation();
                    //contactDataTransformation.ContactId = contact.ContactId;
                    //contactDataTransformation.AddressLine1 = contact.AddressLine1;
                    //contactDataTransformation.AddressLine2 = contact.AddressLine2;
                    //contactDataTransformation.City = contact.City;
                    //contactDataTransformation.Region = contact.Region;
                    //contactDataTransformation.PostalCode = contact.PostalCode;
                    //contactDataTransformation.ContactName = contact.Name;
                    //contactDataTransformation.AccountId = contact.AccountId;
                    contactDataTransformation = _mapper.Map <ContactDataTransformation>(contact);
                    salesOrders.Add(contactDataTransformation);
                }

                returnResponse.Entity     = salesOrders;
                returnResponse.TotalRows  = dataGridPagingInformation.TotalRows;
                returnResponse.TotalPages = dataGridPagingInformation.TotalPages;

                returnResponse.ReturnStatus = true;
            }
            catch (Exception ex)
            {
                _contactManagementDataService.RollbackTransaction();
                returnResponse.ReturnStatus = false;
                returnResponse.ReturnMessage.Add(ex.Message);
            }
            finally
            {
                _contactManagementDataService.CloseConnection();
            }

            return(returnResponse);
        }
        public List <taccount> AccountInquiry(string firstName, string lastName, DataGridPagingInformation paging, out TransactionalInformation transaction)
        {
            transaction = new TransactionalInformation();

            string sortExpression = paging.SortExpression;

            if (paging.SortDirection != string.Empty)
            {
                sortExpression = sortExpression + " " + paging.SortDirection;
            }

            List <taccount> accountList = new List <taccount>();

            int numberOfRows = 0;

            var customerQuery = dbConnection.taccounts.AsQueryable();

            if (firstName != null && firstName.Trim().Length > 0)
            {
                customerQuery = customerQuery.Where(c => c.FIRSTNAME.StartsWith(firstName));
            }

            if (lastName != null && lastName.Trim().Length > 0)
            {
                customerQuery = customerQuery.Where(c => c.LASTNAME.StartsWith(lastName));
            }

            //var orders = from customer in customerQuery
            //                join order in dbConnection.Orders on customer.CustomerID equals order.CustomerID
            //                select new { customer, order, order.OrderDate, order.OrderTotal, customer.CustomerCode, customer.CompanyName };

            numberOfRows = customerQuery.Count();

            customerQuery = customerQuery.OrderBy(acc => acc.FIRSTNAME);

            var accounts = customerQuery.Skip((paging.CurrentPageNumber - 1) * paging.PageSize).Take(paging.PageSize);

            paging.TotalRows  = numberOfRows;
            paging.TotalPages = Utilities.CalculateTotalPages(numberOfRows, paging.PageSize);

            foreach (var account in accounts)
            {
                accountList.Add(account);
            }

            transaction.TotalPages   = paging.TotalPages;
            transaction.TotalRows    = paging.TotalRows;
            transaction.ReturnStatus = true;
            transaction.ReturnMessage.Add(numberOfRows.ToString() + " account found.");

            return(accountList);
        }
        ///// <summary>
        ///// Get Payment Type
        ///// </summary>
        ///// <param name="paymentTypeID"></param>
        ///// <returns></returns>
        //public PaymentType GetPaymentType(Guid paymentTypeID)
        //{
        //    var paymentInformation = dbConnection.PaymentTypes.First(p => p.PaymentTypeID == paymentTypeID);
        //    PaymentType paymentType = paymentInformation as PaymentType;
        //    return paymentInformation;
        //}

        /// <summary>
        /// SysLog Inquiry
        /// </summary>
        /// <param name="firstName"></param>
        /// <param name="lastName"></param>
        /// <param name="paging"></param>
        /// <returns></returns>
        public List <SysLogInquiry> SysLogInquiry(string queryStr, DataGridPagingInformation paging)
        {
            string sortExpression = paging.SortExpression;

            if (paging.SortDirection != string.Empty)
            {
                sortExpression = sortExpression + " " + paging.SortDirection;
            }

            var sysLogQuery = dbConnection.SysLogs.AsQueryable();

            if (queryStr != null && queryStr.Trim().Length > 0)
            {
                sysLogQuery = sysLogQuery.Where(c => c.Id.StartsWith(queryStr));
            }

            //if (lastName != null && lastName.Trim().Length > 0)
            //{
            //    sysLogQuery = sysLogQuery.Where(c => c.LastName.StartsWith(lastName));
            //}

            var sysLogs = from c in sysLogQuery
                          //join p in dbConnection.PaymentTypes on c.PaymentTypeID equals p.PaymentTypeID
                          select new { c.Id, c.Operator, c.Message, c.Result, c.Type, c.Module, c.CreateTime };

            int numberOfRows = sysLogs.Count();

            sysLogs = sysLogs.OrderBy(sortExpression);

            var sysLogList = sysLogs.Skip((paging.CurrentPageNumber - 1) * paging.PageSize).Take(paging.PageSize);

            paging.TotalRows  = numberOfRows;
            paging.TotalPages = Utilities.CalculateTotalPages(numberOfRows, paging.PageSize);

            List <SysLogInquiry> sysLogInquiry = new List <SysLogInquiry>();

            foreach (var sysLog in sysLogList)
            {
                SysLogInquiry sysLogData = new SysLogInquiry();
                sysLogData.Id         = sysLog.Id;
                sysLogData.Operator   = sysLog.Operator;
                sysLogData.Message    = sysLog.Message;
                sysLogData.Result     = sysLog.Result;
                sysLogData.Type       = sysLog.Type;
                sysLogData.Module     = sysLog.Module;
                sysLogData.CreateTime = sysLog.CreateTime;
                sysLogInquiry.Add(sysLogData);
            }

            return(sysLogInquiry);
        }
예제 #14
0
        public List <contact> ContactInquiry(string firstName, string lastName, DataGridPagingInformation paging, out TransactionalInformation transaction)
        {
            transaction = new TransactionalInformation();

            string sortExpression = paging.SortExpression;

            if (paging.SortDirection != string.Empty)
            {
                sortExpression = sortExpression + " " + paging.SortDirection;
            }

            List <contact> contactList = new List <contact>();

            int numberOfRows = 0;

            var customerQuery = dbConnection.contacts.AsQueryable();

            if (firstName != null && firstName.Trim().Length > 0)
            {
                customerQuery = customerQuery.Where(c => c.FirstName.StartsWith(firstName));
            }

            if (lastName != null && lastName.Trim().Length > 0)
            {
                customerQuery = customerQuery.Where(c => c.LastName.StartsWith(lastName));
            }

            numberOfRows  = customerQuery.Count();
            customerQuery = customerQuery.OrderBy(con => con.FirstName);

            var contacts = customerQuery.Skip((paging.CurrentPageNumber - 1) * paging.PageSize).Take(paging.PageSize);

            paging.TotalRows  = numberOfRows;
            paging.TotalPages = Utilities.CalculateTotalPages(numberOfRows, paging.PageSize);

            foreach (var cont in contacts)
            {
                contactList.Add(cont);
            }

            transaction.TotalPages   = paging.TotalPages;
            transaction.TotalRows    = paging.TotalRows;
            transaction.ReturnStatus = true;
            transaction.ReturnMessage.Add(numberOfRows.ToString() + " contact found.");

            return(contactList);
        }
예제 #15
0
        /// <summary>
        /// SysSample Inquiry
        /// </summary>
        /// <param name="firstName"></param>
        /// <param name="lastName"></param>
        /// <param name="paging"></param>
        /// <returns></returns>
        public List <SysSampleInquiry> SysSampleInquiry(string queryStr, DataGridPagingInformation paging)
        {
            string sortExpression = paging.SortExpression;

            if (paging.SortDirection != string.Empty)
            {
                sortExpression = sortExpression + " " + paging.SortDirection;
            }

            var sysSampleQuery = dbConnection.SysSamples.AsQueryable();

            if (queryStr != null && queryStr.Trim().Length > 0)
            {
                sysSampleQuery = sysSampleQuery.Where(c => c.Id.StartsWith(queryStr));
            }


            var sysSamples = from c in sysSampleQuery

                             select new { c.Id, c.Name, c.Age, c.Bir, c.Photo, c.Note, c.CreateTime };

            int numberOfRows = sysSamples.Count();

            sysSamples = sysSamples.OrderBy(sortExpression);

            var sysSampleList = sysSamples.Skip((paging.CurrentPageNumber - 1) * paging.PageSize).Take(paging.PageSize);

            paging.TotalRows  = numberOfRows;
            paging.TotalPages = Utilities.CalculateTotalPages(numberOfRows, paging.PageSize);

            List <SysSampleInquiry> sysSampleInquiry = new List <SysSampleInquiry>();

            foreach (var sysSample in sysSampleList)
            {
                SysSampleInquiry sysSampleData = new SysSampleInquiry();
                sysSampleData.Id         = sysSample.Id;
                sysSampleData.Name       = sysSample.Name;
                sysSampleData.Age        = sysSample.Age;
                sysSampleData.Bir        = sysSample.Bir;
                sysSampleData.Photo      = sysSample.Photo;
                sysSampleData.Note       = sysSample.Note;
                sysSampleData.CreateTime = sysSample.CreateTime;
                sysSampleInquiry.Add(sysSampleData);
            }

            return(sysSampleInquiry);
        }
예제 #16
0
        public List <tkey> APIInquiry(string exchange, string apiKey, DataGridPagingInformation paging, out TransactionalInformation transaction)
        {
            transaction = new TransactionalInformation();

            string sortExpression = paging.SortExpression;

            if (paging.SortDirection != string.Empty)
            {
                sortExpression = sortExpression + " " + paging.SortDirection;
            }

            List <tkey> keyList = new List <tkey>();

            int numberOfRows = 0;

            var customerQuery = dbConnection.tkeys.AsQueryable();

            if (exchange != null && exchange.Trim().Length > 0)
            {
                customerQuery = customerQuery.Where(c => c.EXCHANGE.StartsWith(exchange));
            }

            if (apiKey != null && apiKey.Trim().Length > 0)
            {
                customerQuery = customerQuery.Where(c => c.APIKEY.StartsWith(apiKey));
            }

            numberOfRows  = customerQuery.Count();
            customerQuery = customerQuery.OrderBy(con => con.KEYID);

            var keys = customerQuery.Skip((paging.CurrentPageNumber - 1) * paging.PageSize).Take(paging.PageSize);

            paging.TotalRows  = numberOfRows;
            paging.TotalPages = Utilities.CalculateTotalPages(numberOfRows, paging.PageSize);

            foreach (var key in keys)
            {
                keyList.Add(key);
            }

            transaction.TotalPages   = paging.TotalPages;
            transaction.TotalRows    = paging.TotalRows;
            transaction.ReturnStatus = true;
            transaction.ReturnMessage.Add(numberOfRows.ToString() + " API Key found.");

            return(keyList);
        }
예제 #17
0
        public List <ttrade> TradeInquiry(string OrderID, string OrderStatus, DataGridPagingInformation paging, out TransactionalInformation transaction)
        {
            transaction = new TransactionalInformation();

            string sortExpression = paging.SortExpression;

            if (paging.SortDirection != string.Empty)
            {
                sortExpression = sortExpression + " " + paging.SortDirection;
            }

            List <ttrade> tradeList = new List <ttrade>();

            int numberOfRows  = 0;
            var customerQuery = dbConnection.ttrades.AsQueryable();

            if (OrderID != null && OrderID.Trim().Length > 0)
            {
                customerQuery = customerQuery.Where(c => c.ORDERID.StartsWith(OrderID));
            }

            if (OrderStatus != null && OrderStatus.Trim().Length > 0)
            {
                customerQuery = customerQuery.Where(c => c.ORDERSTATUS.StartsWith(OrderStatus));
            }

            numberOfRows  = customerQuery.Count();
            customerQuery = customerQuery.OrderBy(ord => ord.TID);

            var trades = customerQuery.Skip((paging.CurrentPageNumber - 1) * paging.PageSize).Take(paging.PageSize);

            paging.TotalRows  = numberOfRows;
            paging.TotalPages = Utilities.CalculateTotalPages(numberOfRows, paging.PageSize);

            foreach (var obj in trades)
            {
                tradeList.Add(obj);
            }

            transaction.TotalPages   = paging.TotalPages;
            transaction.TotalRows    = paging.TotalRows;
            transaction.ReturnStatus = true;
            transaction.ReturnMessage.Add(numberOfRows.ToString() + " trade found.");

            return(tradeList);
        }
        /// <summary>
        /// Get All Users
        /// </summary>
        /// <param name="currentPageNumber"></param>
        /// <param name="pageSize"></param>
        /// <param name="sortExpression"></param>
        /// <param name="sortDirection"></param>
        /// <returns></returns>
        public async Task <ResponseModel <List <UserDataTransformation> > > GetAllUsers(string userName, string emailAddress, int currentPageNumber, int pageSize, string sortExpression, string sortDirection)
        {
            ResponseModel <List <UserDataTransformation> > returnResponse = new ResponseModel <List <UserDataTransformation> >();

            List <UserDataTransformation> users = new List <UserDataTransformation>();

            try
            {
                DataGridPagingInformation dataGridPagingInformation = new DataGridPagingInformation();
                dataGridPagingInformation.CurrentPageNumber = currentPageNumber;
                dataGridPagingInformation.PageSize          = pageSize;
                dataGridPagingInformation.SortDirection     = sortDirection;
                dataGridPagingInformation.SortExpression    = sortExpression;

                List <User> userList = await UserListPaging(userName, emailAddress, dataGridPagingInformation);

                foreach (User user in userList)
                {
                    UserDataTransformation userDataTransformation = new UserDataTransformation();
                    userDataTransformation.id           = Convert.ToString(user.Id);
                    userDataTransformation.UserName     = user.UserName;
                    userDataTransformation.EmailAddress = user.EmailAddress;
                    userDataTransformation.IPAddress    = user.IPAddress;
                    userDataTransformation.LimitedTotal = user.LimitedTotal;

                    users.Add(userDataTransformation);
                }

                returnResponse.Entity     = users;
                returnResponse.TotalRows  = dataGridPagingInformation.TotalRows;
                returnResponse.TotalPages = dataGridPagingInformation.TotalPages;

                returnResponse.ReturnStatus = true;
            }
            catch (Exception ex)
            {
                returnResponse.ReturnStatus = false;
                returnResponse.ReturnMessage.Add(ex.Message);
            }
            finally
            {
            }

            return(returnResponse);
        }
        public async Task <ResponseModel <List <ProductDataTransformation> > > GetProduct(string searchText, int currentPageNumber, int pageSize, string sortExpression, string sortDirection)
        {
            ResponseModel <List <ProductDataTransformation> > returnResponse = new ResponseModel <List <ProductDataTransformation> >();

            List <ProductDataTransformation> salesOrders = new List <ProductDataTransformation>();

            try
            {
                _productManagementDataService.OpenConnection(_connectionStrings.PrimaryDatabaseConnectionString);

                DataGridPagingInformation dataGridPagingInformation = new DataGridPagingInformation();
                dataGridPagingInformation.CurrentPageNumber = currentPageNumber;
                dataGridPagingInformation.PageSize          = pageSize;
                dataGridPagingInformation.SortDirection     = sortDirection;
                dataGridPagingInformation.SortExpression    = sortExpression;

                List <Product> productsList = await _productManagementDataService.GetProducts(searchText, searchText, dataGridPagingInformation);

                foreach (Product product in productsList)
                {
                    ProductDataTransformation productDataTransformation = new ProductDataTransformation();
                    productDataTransformation = _mapper.Map <ProductDataTransformation>(product);
                    salesOrders.Add(productDataTransformation);
                }

                returnResponse.Entity     = salesOrders;
                returnResponse.TotalRows  = dataGridPagingInformation.TotalRows;
                returnResponse.TotalPages = dataGridPagingInformation.TotalPages;

                returnResponse.ReturnStatus = true;
            }
            catch (Exception ex)
            {
                _productManagementDataService.RollbackTransaction();
                returnResponse.ReturnStatus = false;
                returnResponse.ReturnMessage.Add(ex.Message);
            }
            finally
            {
                _productManagementDataService.CloseConnection();
            }

            return(returnResponse);
        }
예제 #20
0
        public void CustomerInquiryIntegrationTest()
        {
            TransactionalInformation transaction;

            CustomerApplicationService customerApplicationService = new CustomerApplicationService(customerDataService);

            DataGridPagingInformation paging = new DataGridPagingInformation();

            paging.CurrentPageNumber = 1;
            paging.PageSize          = 15;
            paging.SortExpression    = "LastName";
            paging.SortDirection     = "ASC";

            List <CustomerInquiry> customers = customerApplicationService.CustomerInquiry("", "", paging, out transaction);

            string returnMessage = Utilities.GetReturnMessage(transaction.ReturnMessage);

            Assert.AreEqual(15, customers.Count, returnMessage);
        }
예제 #21
0
 /// <summary>
 /// SysException Inquiry
 /// </summary>
 /// <param name="transaction"></param>
 /// <returns></returns>
 public List <SysExceptionInquiry> SysExceptionInquiry(string queryStr, DataGridPagingInformation paging, out TransactionalInformation transaction)
 {
     transaction = new TransactionalInformation();
     try
     {
         SysExceptionDataService.CreateSession();
         List <SysExceptionInquiry> sysExceptionInquiry = SysExceptionDataService.SysExceptionInquiry(queryStr, paging);
         transaction.ReturnStatus = true;
         return(sysExceptionInquiry);
     }
     catch (Exception ex)
     {
         transaction.ReturnMessage = new List <string>();
         string errorMessage = ex.Message;
         transaction.ReturnStatus = false;
         transaction.ReturnMessage.Add(errorMessage);
         return(null);
     }
     finally
     {
         SysExceptionDataService.CloseSession();
     }
 }
예제 #22
0
        public async Task <List <Product> > GetProducts(string status, string name, DataGridPagingInformation paging)
        {
            string sortExpression = paging.SortExpression;
            string sortDirection  = paging.SortDirection;

            if (string.IsNullOrEmpty(sortExpression))
            {
                sortExpression = "Name";
            }

            if (paging.SortDirection != string.Empty)
            {
                sortExpression = sortExpression + " " + paging.SortDirection;
            }

            int numberOfRows = 0;

            var query = dbConnection.Products.AsQueryable();

            if (name.Trim().Length > 0)
            {
                query = query.Where(p => p.Name.Contains(name));
            }

            //query = query.Where(p => p.AccountId == accountId);

            var resultsList = from p in query select p;

            numberOfRows = await resultsList.CountAsync();

            List <Product> products = await resultsList.Skip((paging.CurrentPageNumber - 1) *paging.PageSize).Take(paging.PageSize).ToListAsync();

            paging.TotalRows  = numberOfRows;
            paging.TotalPages = Utilities.Functions.CalculateTotalPages(numberOfRows, paging.PageSize);

            return(products);
        }
        /// <summary>
        /// Customer Inquiry
        /// </summary>
        /// <param name="firstName"></param>
        /// <param name="lastName"></param>
        /// <param name="paging"></param>
        /// <returns></returns>
        public List <CustomerInquiry> CustomerInquiry(string firstName, string lastName, DataGridPagingInformation paging)
        {
            string sortExpression = paging.SortExpression;

            if (paging.SortDirection != string.Empty)
            {
                sortExpression = sortExpression + " " + paging.SortDirection;
            }

            var customerQuery = Customers.AsQueryable();

            if (firstName != null && firstName.Trim().Length > 0)
            {
                customerQuery = customerQuery.Where(c => c.FirstName.StartsWith(firstName));
            }

            if (lastName != null && lastName.Trim().Length > 0)
            {
                customerQuery = customerQuery.Where(c => c.LastName.StartsWith(lastName));
            }

            var customers = from c in customerQuery
                            join p in PaymentTypes on c.PaymentTypeID equals p.PaymentTypeID
                            select new { c.CustomerID, c.FirstName, c.LastName, c.EmailAddress, c.City, p.Description };

            int numberOfRows = customers.Count();

            customers = customers.OrderBy(sortExpression);

            var customerList = customers.Skip((paging.CurrentPageNumber - 1) * paging.PageSize).Take(paging.PageSize);

            paging.TotalRows  = numberOfRows;
            paging.TotalPages = Utilities.CalculateTotalPages(numberOfRows, paging.PageSize);

            List <CustomerInquiry> customerInquiry = new List <CustomerInquiry>();

            foreach (var customer in customerList)
            {
                CustomerInquiry customerData = new CustomerInquiry();
                customerData.CustomerID             = customer.CustomerID;
                customerData.FirstName              = customer.FirstName;
                customerData.LastName               = customer.LastName;
                customerData.EmailAddress           = customer.EmailAddress;
                customerData.City                   = customer.City;
                customerData.PaymentTypeDescription = customer.Description;
                customerInquiry.Add(customerData);
            }

            return(customerInquiry);
        }
 /// <summary>
 /// Customer Inquiry
 /// </summary>
 /// <param name="firstName"></param>
 /// <param name="lastName"></param>
 /// <param name="paging"></param>
 /// <param name="transaction"></param>
 /// <returns></returns>
 public List <CustomerInquiry> CustomerInquiry(string firstName, string lastName, DataGridPagingInformation paging, out TransactionalInformation transaction)
 {
     transaction = new TransactionalInformation();
     try
     {
         CustomerDataService.CreateSession();
         List <CustomerInquiry> customers = CustomerDataService.CustomerInquiry(firstName, lastName, paging);
         transaction.ReturnStatus = true;
         return(customers);
     }
     catch (Exception ex)
     {
         transaction.ReturnMessage = new List <string>();
         string errorMessage = ex.Message;
         transaction.ReturnStatus = false;
         transaction.ReturnMessage.Add(errorMessage);
         return(null);
     }
     finally
     {
         CustomerDataService.CloseSession();
     }
 }
        public HttpResponseMessage ProductInquiry([FromUri] ProductInquiryDTO productInquiryDTO)
        {
            if (productInquiryDTO.ProductCode == null)
            {
                productInquiryDTO.ProductCode = string.Empty;
            }
            if (productInquiryDTO.Description == null)
            {
                productInquiryDTO.Description = string.Empty;
            }
            if (productInquiryDTO.SortDirection == null)
            {
                productInquiryDTO.SortDirection = string.Empty;
            }
            if (productInquiryDTO.SortExpression == null)
            {
                productInquiryDTO.SortExpression = string.Empty;
            }

            ProductsApiModel         productsWebApiModel = new ProductsApiModel();
            TransactionalInformation transaction         = new TransactionalInformation();
            ProductsBusinessService  productsBusinessService;

            productsWebApiModel.IsAuthenicated = true;

            DataGridPagingInformation paging = new DataGridPagingInformation();

            paging.CurrentPageNumber = productInquiryDTO.CurrentPageNumber;
            paging.PageSize          = productInquiryDTO.PageSize;
            paging.SortExpression    = productInquiryDTO.SortExpression;
            paging.SortDirection     = productInquiryDTO.SortDirection;

            if (paging.SortDirection == "")
            {
                paging.SortDirection = "ASC";
            }
            if (paging.SortExpression == "")
            {
                paging.SortExpression = "Description";
            }

            productsBusinessService = new ProductsBusinessService(productsDataService);

            List <Product> products = productsBusinessService.ProductInquiry(productInquiryDTO.ProductCode, productInquiryDTO.Description, paging, out transaction);

            productsWebApiModel.Products      = products;
            productsWebApiModel.ReturnStatus  = transaction.ReturnStatus;
            productsWebApiModel.ReturnMessage = transaction.ReturnMessage;
            productsWebApiModel.TotalPages    = transaction.TotalPages;
            productsWebApiModel.TotalRows     = transaction.TotalRows;
            productsWebApiModel.PageSize      = paging.PageSize;

            if (transaction.ReturnStatus == true)
            {
                var response = Request.CreateResponse <ProductsApiModel>(HttpStatusCode.OK, productsWebApiModel);
                return(response);
            }

            var badResponse = Request.CreateResponse <ProductsApiModel>(HttpStatusCode.BadRequest, productsWebApiModel);

            return(badResponse);
        }
        public JsonResult GetList(string queryStr, int page, int rows, string SortExpression, string SortDirection)
        {
            //int total = 0;

            TransactionalInformation transaction;

            if (queryStr == null)
            {
                queryStr = string.Empty;
            }
            if (SortDirection == null)
            {
                SortDirection = string.Empty;
            }
            if (SortExpression == null)
            {
                SortExpression = string.Empty;
            }

            SysSampleInquiryViewModel sysSampleInquiryViewModel = new SysSampleInquiryViewModel();

            DataGridPagingInformation paging = new DataGridPagingInformation();

            paging.CurrentPageNumber = page;
            paging.PageSize          = rows;
            paging.SortExpression    = SortExpression;;
            paging.SortDirection     = SortDirection;

            if (paging.SortDirection == "")
            {
                paging.SortDirection = "ASC";
            }
            if (paging.SortExpression == "")
            {
                paging.SortExpression = "Id";
            }

            SysSampleApplicationService sysSampleApplicationService = new SysSampleApplicationService(sysSampleDataService);
            List <SysSampleInquiry>     sysSamples = sysSampleApplicationService.GetSysSampleInquiry(queryStr, paging, out transaction);

            //if (id != string.Empty)
            //{
            sysSampleInquiryViewModel.SysSampleLists = sysSamples;
            sysSampleInquiryViewModel.ReturnStatus   = transaction.ReturnStatus;
            sysSampleInquiryViewModel.ReturnMessage  = transaction.ReturnMessage;

            //sysSampleInquiryViewModel.TotalPages = paging.TotalPages;
            //sysSampleInquiryViewModel.TotalRows = paging.TotalRows;
            //sysSampleInquiryViewModel.PageSize = paging.PageSize;

            var json = new
            {
                total = paging.TotalRows,

                rows = (from r in sysSampleInquiryViewModel.SysSampleLists
                        select new SysSample()
                {
                    Id = r.Id,
                    Name = r.Name,
                    Age = r.Age,
                    Bir = r.Bir,
                    Photo = r.Photo,
                    Note = r.Note,
                    CreateTime = r.CreateTime,
                }).ToArray()
            };

            return(Json(json, JsonRequestBehavior.AllowGet));
        }
 public Task <List <Contact> > ContactInquiry(int accountId, string contactName, DataGridPagingInformation paging)
 {
     throw new NotImplementedException();
 }
        /// <summary>
        /// User Inquiry
        /// </summary>
        /// <param name="userName"></param>
        /// <param name="emailAddress"></param>
        /// <param name="paging"></param>
        /// <returns></returns>
        public async Task <List <User> > UserListPaging(string userName, string emailAddress, DataGridPagingInformation paging)
        {
            string sortExpression = paging.SortExpression;
            string sortDirection  = paging.SortDirection;

            int sortOrder = 1;

            if (sortDirection == "desc")
            {
                sortOrder = -1;
            }

            if (paging.CurrentPageNumber > 0)
            {
                paging.CurrentPageNumber = paging.CurrentPageNumber - 1;
            }

            if (string.IsNullOrEmpty(sortExpression))
            {
                sortExpression = "{Description: 1}";
            }
            else
            {
                sortExpression = "{" + sortExpression + ": " + sortOrder + "}";
            }

            if (paging.PageSize == 0)
            {
                paging.PageSize = 20;
            }

            //
            //	initialize filter
            //
            FilterDefinition <User> filter = Builders <User> .Filter.Empty;

            userName     = userName.Trim();
            emailAddress = emailAddress.Trim();

            //
            //	filter by user name
            //
            if (userName.Length > 0)
            {
                filter = filter & Builders <User> .Filter.Regex(u => u.UserName,
                                                                new BsonRegularExpression(string.Format("^{0}", userName), "i"));
            }
            //
            //	filter by emailAddress
            //
            if (emailAddress.Length > 0)
            {
                filter = filter & Builders <User> .Filter.Regex(u => u.EmailAddress,
                                                                new BsonRegularExpression(string.Format("{0}", emailAddress), "i"));
            }

            long numberOfRows = await _context.Users.CountDocumentsAsync(filter);

            var userCollection = await _context.Users.Find(filter)
                                 .Skip(paging.CurrentPageNumber * paging.PageSize)
                                 .Limit(paging.PageSize)
                                 .Sort(sortExpression)
                                 .Project(u => new
            {
                u.Id,
                u.UserName,
                u.EmailAddress,
                u.AccessToken,
                u.ExpiresIn,
                u.LimitedTotal,
            })
                                 .ToListAsync();

            List <User> users = new List <User>();

            foreach (var userDocument in userCollection)
            {
                User user = new User();

                user.Id           = userDocument.Id;
                user.UserName     = userDocument.UserName;
                user.EmailAddress = userDocument.EmailAddress;
                user.ExpiresIn    = userDocument.ExpiresIn;
                user.LimitedTotal = userDocument.LimitedTotal;

                users.Add(user);
            }

            paging.TotalRows  = numberOfRows;
            paging.TotalPages = Utils.CalculateTotalPages(numberOfRows, paging.PageSize);

            return(users);
        }
        public List <tmastertrade> MasterTradeInquiry(string TradeType, string TradingPair, DataGridPagingInformation paging, out TransactionalInformation transaction)
        {
            transaction = new TransactionalInformation();

            List <tmastertrade> masterTradeList = new List <tmastertrade>();

            try
            {
                masterTradesDataService.CreateSession();
                masterTradeList = masterTradesDataService.MasterTradeInquiry(TradeType, TradingPair, paging, out transaction);
            }
            catch (Exception ex)
            {
                transaction.ReturnMessage = new List <string>();
                string errorMessage = ex.Message;
                transaction.ReturnStatus = false;
                transaction.ReturnMessage.Add(errorMessage);
            }
            finally
            {
                masterTradesDataService.CloseSession();
            }

            return(masterTradeList);
        }
예제 #30
0
        /// <summary>
        /// SysLog Inquiry
        /// </summary>
        /// <returns></returns>
        public List <SysLogInquiry> SysLogInquiry(string queryStr, DataGridPagingInformation paging)
        {
            List <SysLog> sysLogs = new List <SysLog>();

            string sortExpression = paging.SortExpression;

            int maxRowNumber;
            int minRowNumber;

            minRowNumber = (paging.PageSize * (paging.CurrentPageNumber - 1)) + 1;
            maxRowNumber = paging.PageSize * paging.CurrentPageNumber;

            StringBuilder sqlBuilder      = new StringBuilder();
            StringBuilder sqlWhereBuilder = new StringBuilder();

            string sqlWhere = string.Empty;

            if (queryStr != null && queryStr.Trim().Length > 0)
            {
                sqlWhereBuilder.Append(" c.Id LIKE @Id AND ");
            }


            if (sqlWhereBuilder.Length > 0)
            {
                sqlWhere = " WHERE " + sqlWhereBuilder.ToString().Substring(0, sqlWhereBuilder.Length - 4);
            }

            sqlBuilder.Append(" SELECT COUNT(*) as total_records FROM SysLog c ");
            sqlBuilder.Append(sqlWhere);
            sqlBuilder.Append(";");
            sqlBuilder.Append(" SELECT* FROM(");
            sqlBuilder.Append(" SELECT (ROW_NUMBER() OVER (ORDER BY " + paging.SortExpression + " " + paging.SortDirection + ")) as record_number,");
            sqlBuilder.Append(" c.*");
            sqlBuilder.Append(" FROM SysLog c");
            sqlBuilder.Append(sqlWhere);
            sqlBuilder.Append(" ) Rows");
            sqlBuilder.Append(" where record_number between " + minRowNumber + " and " + maxRowNumber);

            string sql = sqlBuilder.ToString();

            SqlCommand sqlCommand = new SqlCommand();

            sqlCommand.Connection  = dbConnection;
            sqlCommand.CommandText = sql;

            if (queryStr != null && queryStr.Trim().Length > 0)
            {
                sqlCommand.Parameters.Add("@Id", System.Data.SqlDbType.NVarChar);
                sqlCommand.Parameters["@Id"].Value = queryStr + "%";
            }

            SqlDataReader reader = sqlCommand.ExecuteReader();

            reader.Read();
            paging.TotalRows  = Convert.ToInt32(reader["Total_Records"]);
            paging.TotalPages = Utilities.CalculateTotalPages(paging.TotalRows, paging.PageSize);

            reader.NextResult();

            List <SysLogInquiry> sysLogList = new List <SysLogInquiry>();

            while (reader.Read())
            {
                DataReader dataReader = new DataReader(reader);

                SysLogInquiry sysLog = new SysLogInquiry();

                sysLog.Id         = dataReader.GetString("Id");
                sysLog.Operator   = dataReader.GetString("Operator");
                sysLog.Message    = dataReader.GetString("Message");
                sysLog.Result     = dataReader.GetString("Result");
                sysLog.Type       = dataReader.GetString("Type");
                sysLog.Module     = dataReader.GetString("Module");
                sysLog.CreateTime = dataReader.GetDateTime("CreateTime");

                sysLogList.Add(sysLog);
            }
            reader.Close();
            return(sysLogList);
        }