public IList <ServiceMethod> FindAllRefCursorProcsByApplicationId(Guid applicationId)
        {
            string[] paramNames  = { "applicationId" };
            object[] paramValues = { applicationId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <ServiceMethod>("ServiceMethod.FindAllRefCursorProcsByApplicationId", paramNames, paramValues));
        }
        public IList <ServiceMethod> FindAllByService(Guid serviceId)
        {
            string[] paramNames  = { "serviceId" };
            object[] paramValues = { serviceId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <ServiceMethod>("ServiceMethod.FindAllByService", paramNames, paramValues));
        }
        public IList <DAD.Action> FindByBusinessEntityId(Guid businessEntityId)
        {
            string[] paramNames  = { "businessEntityId" };
            object[] paramValues = { businessEntityId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <DAD.Action>("Action.FindByBusinessEntityId", paramNames, paramValues));
        }
Пример #4
0
        public IList <View> FindAll(Guid applicationId)
        {
            string[] paramNames  = { "applicationId" };
            object[] paramValues = { applicationId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <View>("View.FindAllByApplication", paramNames, paramValues));
        }
Пример #5
0
        public IList <View> FindByNameAndApplicationId(string viewName, Guid applicationId)
        {
            string[] paramNames  = { "viewName", "applicationId" };
            object[] paramValues = { viewName, applicationId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <View>("View.FindByNameAndApplicationId", paramNames, paramValues));
        }
Пример #6
0
        public IList <WorkflowDialog> FindAllByDialogId(Guid dialogId)
        {
            string[] paramNames  = { "dialogId" };
            object[] paramValues = { dialogId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <WorkflowDialog>("WorkflowDialog.FindAllByDialogId", paramNames, paramValues));
        }
        public IList <Report> FindAllReports(Guid applicationId)
        {
            string[] paramNames  = { "applicationId" };
            object[] paramValues = { applicationId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <Report>("Report.FindAllReports", paramNames, paramValues));
        }
Пример #8
0
        public IList <Service> FindAll(Guid applicationId)
        {
            string[] paramNames  = { "applicationId" };
            object[] paramValues = { applicationId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <Service>("Service.FindAll", paramNames, paramValues));
        }
Пример #9
0
        public IList <ViewAction> FindAllByActionIdAndViewNodeId(Guid actionId, Guid viewNodeId)
        {
            string[] paramNames  = { "actionId", "viewNodeId" };
            object[] paramValues = { actionId, viewNodeId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <ViewAction>("ViewAction.FindAllByActionIdAndViewNodeId", paramNames, paramValues));
        }
Пример #10
0
        public IList <ViewAction> FindByMappedPropertyId(Guid mappedPropertyId)
        {
            string[] paramNames  = { "mappedPropertyId" };
            object[] paramValues = { mappedPropertyId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <ViewAction>("ViewAction.FindByMappedPropertyId", paramNames, paramValues));
        }
        public IList <WorkflowSubworkflow> FindAllByWorkflowId(Guid workflowId)
        {
            string[] paramNames  = { "workflowId" };
            object[] paramValues = { workflowId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <WorkflowSubworkflow>("WorkflowSubworkflow.FindAllByWorkflowId", paramNames, paramValues));
        }
Пример #12
0
        public IList <CustomDialog> FindAll(Guid applicationId)
        {
            string[] paramNames  = { "applicationId" };
            object[] paramValues = { applicationId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <CustomDialog>("CustomDialog.FindAll", paramNames, paramValues));
        }
        public IList <UXAction> FindAllByServiceMethodId(Guid serviceMethodId)
        {
            string[] paramNames  = { "serviceMethodId" };
            object[] paramValues = { serviceMethodId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <UXAction>("UXAction.FindAllByServiceMethodId", paramNames, paramValues));
        }
Пример #14
0
        public IList <MenuItem> FindAllByActionId(Guid actionId)
        {
            string[] paramNames  = { "actionId" };
            object[] paramValues = { actionId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <MenuItem>("MenuItem.FindAllByActionId", paramNames, paramValues));
        }
Пример #15
0
        public IList <Dialog> FindAllDrilldownDialogs(Guid applicationId)
        {
            string[] paramNames  = { "applicationId", "dialogType" };
            object[] paramValues = { applicationId, (int)DialogType.Drilldown };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <Dialog>("Dialog.FindAllDrilldownDialogs", paramNames, paramValues));
        }
Пример #16
0
        public IList <Dialog> FindAllByModule(Guid moduleId)
        {
            string[] paramNames  = { "moduleId" };
            object[] paramValues = { moduleId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <Dialog>("Dialog.FindAllByModule", paramNames, paramValues));
        }
Пример #17
0
        public IList <Dialog> FindDialogsByNameAndModule(Guid applicationId, string moduleName, string dialogName)
        {
            string[] paramNames  = { "applicationId", "moduleName", "dialogName" };
            object[] paramValues = { applicationId, moduleName, dialogName };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <Dialog>("Dialog.FindDialogsByNameAndModule", paramNames, paramValues));
        }
Пример #18
0
        public IList <Dialog> FindAllDialogsWithInterfaceViewByDialogType(Guid applicationId, DialogType dialogType)
        {
            string[] paramNames  = { "applicationId", "dialogType" };
            object[] paramValues = { applicationId, dialogType };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <Dialog>("Dialog.FindAllDialogsWithInterfaceViewByDialogType", paramNames, paramValues));
        }
        private void DeleteIssuesForObjectId(Guid applicationId, IssueObjectType type, Guid objectId, IList <Issue> dontDeleteIssueList)
        {
            IList <Issue> foundIssues = null;

            Guid[] varIdList = null;

            if (dontDeleteIssueList == null ||
                dontDeleteIssueList.Count == 0)
            {
                varIdList = new List <Guid> {
                    Guid.Empty
                }.ToArray();
            }
            else
            {
                // Get the id's from the Issuelist
                varIdList = dontDeleteIssueList.Select(x => x.Id).ToArray();
            }

            string[] paramNames  = { "applicationId", "objectType", "objectId", "exceptionIdList" };
            object[] paramValues = { applicationId, (int)type, objectId, varIdList };

            foundIssues = HibernateTemplate.FindByNamedQueryAndNamedParam <Issue>("Issue.SelectToDeleteIssuesForObjectId", paramNames, paramValues);

            if (foundIssues != null && foundIssues.Count > 0)
            {
                foreach (Issue issue in foundIssues)
                {
                    Delete(issue);
                }
            }
        }
Пример #20
0
        public IList <Dialog> FindDialogs(Guid applicationId, string moduleName, string dialogName, string originalDialogName, string title)
        {
            if (string.IsNullOrEmpty(moduleName))
            {
                moduleName = "%";
            }

            if (string.IsNullOrEmpty(dialogName))
            {
                dialogName = "%";
            }

            if (string.IsNullOrEmpty(originalDialogName))
            {
                originalDialogName = "%";
            }

            if (string.IsNullOrEmpty(title))
            {
                title = "%";
            }

            string[] paramNames  = { "applicationId", "moduleName", "dialogName", "originalDialogName", "title" };
            object[] paramValues = { applicationId, moduleName, dialogName, originalDialogName, title };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <Dialog>("Dialog.FindDialogs", paramNames, paramValues));
        }
        public IList <UXAction> FindAllByDialogId(Guid dialogId)
        {
            string[] paramNames  = { "dialogId" };
            object[] paramValues = { dialogId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <UXAction>("UXAction.FindDialogAction", paramNames, paramValues));
        }
        public IList <Issue> FindAllIssuesByTypeAndObjectId(Guid applicationId, IssueObjectType type, Guid objectId)
        {
            string[] paramNames  = { "applicationId", "objectType", "objectId" };
            object[] paramValues = { applicationId, (int)type, objectId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <Issue>("Issue.FindAllIssuesByTypeAndObjectId", paramNames, paramValues));
        }
Пример #23
0
        public IList <BusinessEntity> FindAll(Guid applicationId)
        {
            string[] paramNames  = { "applicationId" };
            object[] paramValues = { applicationId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <BusinessEntity>("BusinessEntity.FindAll", paramNames, paramValues));
        }
        public IList <UXAction> FindAllUnmapped(Guid applicationId)
        {
            string[] paramNames  = { "applicationId" };
            object[] paramValues = { applicationId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <UXAction>("UXAction.FindAllUnmappedAction", paramNames, paramValues));
        }
        public IList <UXAction> FindAllByWorkflowId(Guid workflowId)
        {
            string[] paramNames  = { "workflowId" };
            object[] paramValues = { workflowId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <UXAction>("UXAction.FindWorkflowAction", paramNames, paramValues));
        }
        public IList <DeploymentGroup> FindAllWithApplication(Guid applicationId)
        {
            string[] paramNames  = { "applicationId" };
            object[] paramValues = { applicationId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <DeploymentGroup>("DeploymentGroup.FindAllWithApplication", paramNames, paramValues));
        }
        public IList <ViewNode> FindAllByViewId(Guid viewId)
        {
            string[] paramNames  = { "viewId" };
            object[] paramValues = { viewId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <ViewNode>("ViewNode.FindAllByViewId", paramNames, paramValues));
        }
Пример #28
0
        public IList <Package> FindAllBySchemaId(Guid schemaId)
        {
            string[] paramNames  = { "schemaId" };
            object[] paramValues = { schemaId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <Package>("Package.FindAllBySchemaId",
                                                                             paramNames, paramValues));
        }
Пример #29
0
        public IList <Container> FindContainer(string containerName)
        {
            string[] paramNames  = { "containerName" };
            object[] paramValues = { (containerName ?? "%") };

            IList <Container> result = HibernateTemplate.FindByNamedQueryAndNamedParam <Container>("Container.FindContainerByContainerName", paramNames, paramValues);

            return(result);
        }
Пример #30
0
        public IList <Blob> FindContainerBlob(string containerName, string blobName)
        {
            string[] paramNames  = { "containerName", "blobName" };
            object[] paramValues = { containerName, (blobName ?? "%") };

            IList <Blob> result = HibernateTemplate.FindByNamedQueryAndNamedParam <Blob>("Blob.FindContainerBlob", paramNames, paramValues);

            return(result);
        }