Beispiel #1
0
        public static async Task <IEnumerable <SolutionEntity> > FetchAllAsync()
        {
            const string selectSql = @"
                SELECT s.Id AS SolutionId,
                       c.[Name],
                       s.[Version],
                       s.Summary,
                       s.FullDescription,
                       s.Features,
                       s.ClientApplication,
                       s.Hosting,
                       s.ImplementationDetail,
                       s.RoadMap,
                       s.IntegrationsUrl,
                       s.AboutUrl,
                       s.ServiceLevelAgreement,
                       s.WorkOfPlan,
                       s.LastUpdated,
                       s.LastUpdatedBy
                  FROM dbo.Solution AS s
                       INNER JOIN dbo.CatalogueItem AS c
                               ON c.CatalogueItemId = s.Id;";

            return(await SqlRunner.FetchAllAsync <SolutionEntity>(selectSql));
        }
 public static async Task <IEnumerable <SolutionSupplierStatusEntity> > FetchAllAsync()
 {
     return(await SqlRunner.FetchAllAsync <SolutionSupplierStatusEntity>($@"
     SELECT  [Id]
             ,[Name]
     FROM    SolutionSupplierStatus")
            .ConfigureAwait(false));
 }
 public static async Task <IEnumerable <FrameworkSolutionEntity> > FetchAllAsync()
 {
     return(await SqlRunner.FetchAllAsync <FrameworkSolutionEntity>($@"SELECT [FrameworkId]
                           ,[SolutionId]
                           ,[IsFoundation]
                           ,[LastUpdated]
                           ,[LastUpdatedBy]")
            .ConfigureAwait(false));
 }
Beispiel #4
0
        public static async Task <IEnumerable <SupplierEntity> > FetchAllAsync()
        {
            return(await SqlRunner.FetchAllAsync <SupplierEntity>($@"SELECT
                                [Id],
                                [Summary],
                                [SupplierUrl],
	                            [LastUpdated]
                                FROM Supplier").ConfigureAwait(false));
        }
        public static async Task <IEnumerable <string> > FetchAllEpicIdsForSolutionAsync(string solutionId)
        {
            const string selectSql = @"
                SELECT EpicId
                  FROM dbo.SolutionEpic
                 WHERE SolutionId = @solutionId;";

            return(await SqlRunner.FetchAllAsync <string>(selectSql, new { solutionId }));
        }
Beispiel #6
0
 public static async Task <IEnumerable <EpicEntity> > FetchAllAsync()
 {
     return(await SqlRunner.FetchAllAsync <EpicEntity>($@"SELECT [Id]
                         ,[Name]
                         ,[CapabilityId]
                         ,[SourceUrl]
                         ,[CompliancyLevelId]
                         ,[Active]
                         FROM Epic").ConfigureAwait(false));
 }
        public static async Task <IEnumerable <string> > FetchForSolutionAsync(string solutionId)
        {
            const string selectSql = @"
                SELECT c.CapabilityRef
                  FROM dbo.SolutionCapability AS s
                       INNER JOIN Capability AS c
                               ON s.CapabilityId = c.Id
                 WHERE s.SolutionId = @solutionId;";

            return(await SqlRunner.FetchAllAsync <string>(selectSql, new { solutionId }));
        }
Beispiel #8
0
 public static async Task <IEnumerable <string> > FetchAllEpicIdsForSolutionAsync(string solutionId)
 {
     return(await SqlRunner.FetchAllAsync <string>($@"SELECT
                            [EpicId]
                            FROM SolutionEpic
                            WHERE SolutionId = @solutionId;", new
     {
         solutionId
     })
            .ConfigureAwait(false));
 }
        public static async Task <IEnumerable <SupplierEntity> > FetchAllAsync()
        {
            const string selectSql = @"
                SELECT Id,
                       Summary,
                       SupplierUrl,
                       LastUpdated
                  FROM dbo.Supplier;";

            return(await SqlRunner.FetchAllAsync <SupplierEntity>(selectSql));
        }
 public static async Task <IEnumerable <string> > FetchForSolutionAsync(string solutionId)
 {
     return(await SqlRunner.FetchAllAsync <string>($@"SELECT
                            [Capability].[CapabilityRef]
                            FROM SolutionCapability
                            INNER JOIN Capability ON SolutionCapability.CapabilityId = Capability.Id
                            WHERE SolutionId = @solutionId;", new
     {
         solutionId
     })
            .ConfigureAwait(false));
 }
        public static async Task <IEnumerable <CatalogueItemEntity> > FetchAllAsync()
        {
            const string selectSql = @"
                SELECT CatalogueItemId,
                       [Name],
                       Created,
                       CatalogueItemTypeId,
                       SupplierId,
                       PublishedStatusId
                  FROM dbo.CatalogueItem;";

            return(await SqlRunner.FetchAllAsync <CatalogueItemEntity>(selectSql));
        }
Beispiel #12
0
        public static async Task <IEnumerable <EpicEntity> > FetchAllAsync()
        {
            const string selectSql = @"
                SELECT Id,
                       [Name],
                       CapabilityId,
                       SourceUrl,
                       CompliancyLevelId,
                       Active
                  FROM dbo.Epic;";

            return(await SqlRunner.FetchAllAsync <EpicEntity>(selectSql));
        }
        public static async Task <IEnumerable <SupplierContactEntity> > FetchAllAsync()
        {
            return(await SqlRunner.FetchAllAsync <SupplierContactEntity>(@"
                SELECT  Id,
                        SupplierId,
                        FirstName,
                        LastName,
                        Email,
                        PhoneNumber,
	                    LastUpdated,
	                    LastUpdatedBy
                FROM    Supplier;"));
        }
Beispiel #14
0
 public static async Task <IEnumerable <CapabilityEntity> > FetchAllAsync()
 {
     return(await SqlRunner.FetchAllAsync <CapabilityEntity>($@"SELECT [Id]
                         ,[CapabilityRef]
                         ,[Version]
                         ,[PreviousVersion]
                         ,[StatusId]
                         ,[Name]
                         ,[Description]
                         ,[SourceUrl]
                         ,[EffectiveDate]
                         ,[CategoryId]
                         FROM Capability").ConfigureAwait(false));
 }
 public static async Task <IEnumerable <OrganisationEntity> > FetchAllAsync()
 {
     return(await SqlRunner.FetchAllAsync <OrganisationEntity>($@"SELECT [Id]
                             ,[Name]
                             ,[OdsCode]
                             ,[PrimaryRoleId]
                             ,[CrmRef]
                             ,[Address]
                             ,[CatalogueAgreementSigned]
                             ,[Deleted]
                             ,[LastUpdated]
                             ,[LastUpdatedBy]
                         FROM Organisation")
            .ConfigureAwait(false));
 }
       public static async Task <IEnumerable <SolutionDetailEntity> > FetchAllAsync()
       {
           return(await SqlRunner.FetchAllAsync <SolutionDetailEntity>(@"SELECT Id AS SolutionId,
      Features,
      ClientApplication,
      Hosting,
      ImplementationDetail,
      RoadMap,
      IntegrationsUrl,
      AboutUrl,
      Summary,
      FullDescription,
      LastUpdated,
      LastUpdatedBy
 FROM dbo.Solution;"));
       }
Beispiel #17
0
        public static async Task <IEnumerable <MarketingContactEntity> > FetchForSolutionAsync(string solutionId)
        {
            const string selectSql = @"
                SELECT Id,
                       SolutionId,
                       FirstName,
                       LastName,
                       Email,
                       PhoneNumber,
                       Department,
                       LastUpdated,
                       LastUpdatedBy
                  FROM dbo.MarketingContact
                 WHERE SolutionId = @solutionId;";

            return(await SqlRunner.FetchAllAsync <MarketingContactEntity>(selectSql, new { solutionId }));
        }
 public static async Task<IEnumerable<MarketingContactEntity>> FetchForSolutionAsync(string solutionId)
 {
     return await SqlRunner.FetchAllAsync<MarketingContactEntity>($@"SELECT
      [Id]
     ,[SolutionId]
     ,[FirstName]
     ,[LastName]
     ,[Email]
     ,[PhoneNumber]
     ,[Department]
     ,[LastUpdated]
     ,[LastUpdatedBy]
     FROM MarketingContact
     Where SolutionId = @solutionId",
     new { solutionId }
     ).ConfigureAwait(false);
 }
Beispiel #19
0
        public static async Task <IEnumerable <CapabilityEntity> > FetchAllAsync()
        {
            const string selectSql = @"
                SELECT Id,
                       CapabilityRef,
                       [Version],
                       PreviousVersion,
                       StatusId,
                       [Name],
                       [Description],
                       SourceUrl,
                       EffectiveDate,
                       CategoryId
                  FROM dbo.Capability;";

            return(await SqlRunner.FetchAllAsync <CapabilityEntity>(selectSql));
        }
        public static async Task <IEnumerable <SolutionEntity> > FetchAllAsync()
        {
            return(await SqlRunner.FetchAllAsync <SolutionEntity>($@"SELECT [Id]
                                ,[ParentId]
                                ,[SupplierId]
                                ,[OrganisationId]
                                ,[SolutionDetailId]
                                ,[Name]
	                            ,[Version]
	                            ,[PublishedStatusId]
	                            ,[AuthorityStatusId]
	                            ,[SupplierStatusId]
	                            ,[OnCatalogueVersion]
	                            ,[ServiceLevelAgreement]
	                            ,[WorkOfPlan]
	                            ,[LastUpdated]
	                            ,[LastUpdatedBy]
                                FROM Solution")
                   .ConfigureAwait(false));
        }
Beispiel #21
0
 public static async Task <IEnumerable <SolutionDetailEntity> > FetchAllAsync()
 {
     return(await SqlRunner.FetchAllAsync <SolutionDetailEntity>($@"SELECT 
                    [Id]
                     ,[SolutionId]
                     ,[PublishedStatusId]        
                     ,[Features]
                     ,[ClientApplication]
                     ,[Hosting]
                     ,[ImplementationDetail]
                     ,[RoadMap]
                     ,[RoadMapImageUrl]
                     ,[AboutUrl]
                     ,[Summary]
                     ,[FullDescription]
                     ,[LastUpdated]
                     ,[LastUpdatedBy]
                     FROM SolutionDetail")
            .ConfigureAwait(false));
 }