コード例 #1
0
        public List <Notification> searchNotification(Notification notification, ESearchOption filterOperator)
        {
            List <Notification> result = new List <Notification>();

            try
            {
                result = DAC.DALNotification.searchNotification(notification, filterOperator);
            }
            catch (Exception ex) { Log.error(ex.Message, EErrorFrom.NOTIFICATION); }
            return(result);
        }
コード例 #2
0
        public List <Tax_order> searchTax_order(Tax_order Tax_order, ESearchOption filterOperator)
        {
            List <Tax_order> result = new List <Tax_order>();

            try
            {
                result = DAC.DALOrder.searchTax_order(Tax_order, filterOperator);
            }
            catch (Exception ex) { Log.error(ex.Message, EErrorFrom.ORDER); }
            return(result);
        }
コード例 #3
0
        public List <Order_item> searchOrder_item(Order_item Order_item, ESearchOption filterOperator)
        {
            List <Order_item> result = new List <Order_item>();

            try
            {
                result = DAC.DALOrder.searchOrder_item(Order_item, filterOperator);
            }
            catch (Exception ex) { Log.error(ex.Message, EErrorFrom.ORDER); }
            return(result);
        }
コード例 #4
0
        public async Task <List <Tax> > searchTaxAsync(Tax Tax, ESearchOption filterOperator)
        {
            List <Tax> result = new List <Tax>();

            try
            {
                result = await DAC.DALOrder.searchTaxAsync(Tax, filterOperator);
            }
            catch (Exception ex) { Log.error(ex.Message, EErrorFrom.ORDER); }
            return(result);
        }
コード例 #5
0
        public async Task <List <Delivery> > searchDeliveryAsync(Delivery Delivery, ESearchOption filterOperator)
        {
            List <Delivery> result = new List <Delivery>();

            try
            {
                result = await DAC.DALOrder.searchDeliveryAsync(Delivery, filterOperator);
            }
            catch (Exception ex) { Log.error(ex.Message, EErrorFrom.ORDER); }
            return(result);
        }
コード例 #6
0
        public List <Bill> searchBill(Bill Bill, ESearchOption filterOperator)
        {
            List <Bill> result = new List <Bill>();

            try
            {
                result = DAC.DALOrder.searchBill(Bill, filterOperator);
            }
            catch (Exception ex) { Log.error(ex.Message, EErrorFrom.ORDER); }
            return(result);
        }
コード例 #7
0
        public List <Client> searchClient(Client client, ESearchOption filterOperator)
        {
            List <Client> result = new List <Client>();

            try
            {
                result = DAC.DALClient.searchClient(client, filterOperator);
            }
            catch (Exception ex) { Log.error(ex.Message, EErrorFrom.CLIENT); }
            return(result);
        }
コード例 #8
0
        public async Task <List <Message> > searchMessageAsync(Message message, ESearchOption filterOperator)
        {
            List <Message> result = new List <Message>();

            try
            {
                result = await DAC.DALChatRoom.searchMessageAsync(message, filterOperator);
            }
            catch (Exception ex) { Log.error(ex.Message, EErrorFrom.CHATROOM); }
            return(result);
        }
コード例 #9
0
        public List <Currency> searchCurrency(Currency Currency, ESearchOption filterOperator)
        {
            List <Currency> result = new List <Currency>();

            try
            {
                result = DAC.DALOrder.searchCurrency(Currency, filterOperator);
            }
            catch (Exception ex) { Log.error(ex.Message, EErrorFrom.ORDER); }
            return(result);
        }
コード例 #10
0
        public List <Item_delivery> searchItem_delivery(Item_delivery Item_delivery, ESearchOption filterOperator)
        {
            List <Item_delivery> result = new List <Item_delivery>();

            try
            {
                result = DAC.DALItem.searchItem_delivery(Item_delivery, filterOperator);
            }
            catch (Exception ex) { Log.error(ex.Message, EErrorFrom.ITEM); }
            return(result);
        }
コード例 #11
0
        public async Task <List <Provider> > searchProviderAsync(Provider Provider, ESearchOption filterOperator)
        {
            List <Provider> result = new List <Provider>();

            try
            {
                result = await DAC.DALItem.searchProviderAsync(Provider, filterOperator);
            }
            catch (Exception ex) { Log.error(ex.Message, EErrorFrom.ITEM); }
            return(result);
        }
コード例 #12
0
        public async Task <List <Contact> > searchContactAsync(Contact Contact, ESearchOption filterOperator)
        {
            List <Contact> result = new List <Contact>();

            try
            {
                result = await DAC.DALClient.searchContactAsync(Contact, filterOperator);
            }
            catch (Exception ex) { Log.error(ex.Message, EErrorFrom.CLIENT); }
            return(result);
        }
コード例 #13
0
        public async Task <List <Auto_ref> > searchAuto_refAsync(Auto_ref Auto_ref, ESearchOption filterOperator)
        {
            List <Auto_ref> result = new List <Auto_ref>();

            try
            {
                result = await DAC.DALItem.searchAuto_refAsync(Auto_ref, filterOperator);
            }
            catch (Exception ex) { Log.error(ex.Message, EErrorFrom.ITEM); }
            return(result);
        }
コード例 #14
0
        public List <Info> searchInfo(Info Infos, ESearchOption filterOperator)
        {
            List <Info> result = new List <Info>();

            try
            {
                result = DAC.DALReferential.searchInfo(Infos, filterOperator);
            }
            catch (Exception ex) { Log.error(ex.Message, EErrorFrom.REFERENTIAL); }
            return(result);
        }
コード例 #15
0
        public async Task <List <Tax_item> > searchTax_itemAsync(Tax_item Tax_item, ESearchOption filterOperator)
        {
            List <Tax_item> result = new List <Tax_item>();

            try
            {
                result = await DAC.DALItem.searchTax_itemAsync(Tax_item, filterOperator);
            }
            catch (Exception ex) { Log.error(ex.Message, EErrorFrom.ITEM); }
            return(result);
        }
コード例 #16
0
        public List <Statistic> searchStatistic(Statistic statistic, ESearchOption filterOperator)
        {
            List <Statistic> result = new List <Statistic>();

            try
            {
                result = DAC.DALStatistic.searchStatistic(statistic, filterOperator);
            }
            catch (Exception ex) { Log.error(ex.Message, EErrorFrom.STATISTIC); }
            return(result);
        }
コード例 #17
0
        public async Task <List <Agent> > searchAgentAsync(Agent agent, ESearchOption filterOperator)
        {
            List <Agent> result = new List <Agent>();

            try
            {
                result = await DAC.DALAgent.searchAgentAsync(agent, filterOperator);
            }
            catch (Exception ex) { Log.error(ex.Message, EErrorFrom.AGENT); }
            return(result);
        }
コード例 #18
0
        public async Task <List <Address> > searchAddressAsync(Address Address, ESearchOption filterOperator)
        {
            List <Address> result = new List <Address>();

            try
            {
                result = await DAC.DALClient.searchAddressAsync(Address, filterOperator);
            }
            catch (Exception ex) { Log.error(ex.Message, EErrorFrom.CLIENT); }
            return(result);
        }
コード例 #19
0
        public List <Provider_item> searchProvider_item(Provider_item Provider_item, ESearchOption filterOperator)
        {
            List <Provider_item> result = new List <Provider_item>();

            try
            {
                result = DAC.DALItem.searchProvider_item(Provider_item, filterOperator);
            }
            catch (Exception ex) { Log.error(ex.Message, EErrorFrom.ITEM); }
            return(result);
        }
コード例 #20
0
        public async Task <List <Role> > searchRoleAsync(Role Role, ESearchOption filterOperator)
        {
            List <Role> result = new List <Role>();

            try
            {
                result = await DAC.DALSecurity.searchRoleAsync(Role, filterOperator);
            }
            catch (Exception ex) { Log.error(ex.Message, EErrorFrom.SECURITY); }
            return(result);
        }
コード例 #21
0
        public async Task <List <Item> > searchItemAsync(Item item, ESearchOption filterOperator)
        {
            List <Item> result = new List <Item>();

            try
            {
                result = await DAC.DALItem.searchItemAsync(item, filterOperator);
                await UpdateItemDependenciesAsync(result);
            }
            catch (Exception ex) { Log.error(ex.Message, EErrorFrom.ITEM); }
            return(result);
        }
コード例 #22
0
        public async Task <List <Order> > searchOrderAsync(Order order, ESearchOption filterOperator)
        {
            List <Order> result = new List <Order>();

            try
            {
                result = await DAC.DALOrder.searchOrderAsync(order, filterOperator);
                await UpdateOrderDependenciesAsync(result);
            }
            catch (Exception ex) { Log.error(ex.Message, EErrorFrom.ORDER); }
            return(result);
        }
コード例 #23
0
        public async Task <List <Client> > searchClientAsync(Client client, ESearchOption filterOperator)
        {
            List <Client> result = new List <Client>();

            try
            {
                result = await DAC.DALClient.searchClientAsync(client, filterOperator);
                await UpdateClientDependenciesAsync(result);
            }
            catch (Exception ex) { Log.error(ex.Message, EErrorFrom.CLIENT); }
            return(result);
        }
コード例 #24
0
 public List <Agent> searchAgent(Agent agent, ESearchOption filterOperator)
 {
     if (_servicePortType.State != System.ServiceModel.CommunicationState.Faulted)
     {
         return(_dataSet.searchAgent(agent, filterOperator));
     }
     else
     {
         _serviceCommunication.resetCommunication();
         return(searchAgent(agent, filterOperator));
     }
 }
コード例 #25
0
        public async Task <List <Auto_ref> > searchAuto_refAsync(Auto_ref Auto_ref, ESearchOption filterOperator)
        {
            List <Auto_ref> result = new List <Auto_ref>();

            try
            {
                result = (await _channel.get_filter_auto_refAsync(_companyName, Auto_ref.Auto_refTypeToFilterArray(filterOperator))).ArrayTypeToAuto_ref();
            }
            catch (FaultException) { Dispose(); throw; }
            catch (CommunicationException) { _channel.Abort(); throw; }
            catch (TimeoutException) { _channel.Abort(); }
            return(result);
        }
コード例 #26
0
        public async Task <List <Agent> > searchAgentAsync(Agent agent, ESearchOption filterOperator)
        {
            List <Agent> result = new List <Agent>();

            try
            {
                result = (await _channel.get_filter_agentAsync(_companyName, agent.AgentTypeToFilterArray(filterOperator))).ArrayTypeToAgent();
            }
            catch (FaultException) { Dispose(); throw; }
            catch (CommunicationException) { _channel.Abort(); throw; }
            catch (TimeoutException) { _channel.Abort(); }
            return(result);
        }
コード例 #27
0
        public async Task <List <Role> > searchRoleAsync(Role Role, ESearchOption filterOperator)
        {
            List <Role> result = new List <Role>();

            try
            {
                result = (await _channel.get_filter_roleAsync(_companyName, Role.RoleTypeToFilterArray(filterOperator))).ArrayTypeToRole();
            }
            catch (FaultException) { Dispose(); throw; }
            catch (CommunicationException) { _channel.Abort(); throw; }
            catch (TimeoutException) { _channel.Abort(); }
            return(result);
        }
コード例 #28
0
        public async Task <List <Provider> > searchProviderAsync(Provider Provider, ESearchOption filterOperator)
        {
            List <Provider> result = new List <Provider>();

            try
            {
                result = (await _channel.get_filter_providerAsync(_companyName, Provider.ProviderTypeToFilterArray(filterOperator))).ArrayTypeToProvider();
            }
            catch (FaultException) { Dispose(); throw; }
            catch (CommunicationException) { _channel.Abort(); throw; }
            catch (TimeoutException) { _channel.Abort(); }
            return(result);
        }
コード例 #29
0
        public async Task <List <Tax_item> > searchTax_itemAsync(Tax_item Tax_item, ESearchOption filterOperator)
        {
            List <Tax_item> result = new List <Tax_item>();

            try
            {
                result = (await _channel.get_filter_tax_itemAsync(_companyName, Tax_item.Tax_itemTypeToFilterArray(filterOperator))).ArrayTypeToTax_item();
            }
            catch (FaultException) { Dispose(); throw; }
            catch (CommunicationException) { _channel.Abort(); throw; }
            catch (TimeoutException) { _channel.Abort(); }
            return(result);
        }
コード例 #30
0
        public async Task <List <Address> > searchAddressAsync(Address Address, ESearchOption filterOperator)
        {
            List <Address> result = new List <Address>();

            try
            {
                result = (await _channel.get_filter_addressAsync(_companyName, Address.AddressTypeToFilterArray(filterOperator))).ArrayTypeToAddress();
            }
            catch (FaultException) { Dispose(); throw; }
            catch (CommunicationException) { _channel.Abort(); throw; }
            catch (TimeoutException) { _channel.Abort(); }
            return(result);
        }