/// <summary> /// Set data. Override to to handle multipple resultsets. Takes only first result as Default /// </summary> /// <typeparam name="T"></typeparam> /// <param name="result"></param> /// <returns></returns> protected virtual T SetData(SqlMapper.GridReader result) { return(result.Read <T>().FirstOrDefault()); }
protected virtual async Task <List <T> > PageListItemsAsync(SqlMapper.GridReader gridReader) { var result = await gridReader.ReadAsync <T>(); return(result.ToList()); }
public static async Task <IReadOnlyCollection <Apprenticeship> > MapApprenticeships(SqlMapper.GridReader reader) { var apprenticeships = reader.Read <ApprenticeshipHeaderResult, Standard, ApprenticeshipHeaderResult>( (header, standard) => { header.Standard = standard; return(header); }, splitOn: "StandardCode"); var locations = (reader.Read <ApprenticeshipLocationResult, Venue, ApprenticeshipLocationResult>( (location, venue) => { location.Venue = venue; return(location); }, splitOn: "VenueId")) .GroupBy(al => al.ApprenticeshipId) .ToDictionary(g => g.Key, g => g.AsEnumerable()); var apprenticeshipLocationSubRegions = (await reader.ReadAsync <ApprenticeshipLocationSubRegionResult>()) .GroupBy(r => r.ApprenticeshipLocationId) .ToDictionary(g => g.Key, g => g.Select(r => r.RegionId).AsEnumerable()); return(apprenticeships .Select(a => new Apprenticeship() { ApprenticeshipId = a.ApprenticeshipId, CreatedOn = a.CreatedOn, UpdatedOn = a.UpdatedOn, ProviderId = a.ProviderId, ProviderUkprn = a.ProviderUkprn, Standard = a.Standard, MarketingInformation = a.MarketingInformation, ApprenticeshipWebsite = a.ApprenticeshipWebsite, ContactEmail = a.ContactEmail, ContactTelephone = a.ContactTelephone, ContactWebsite = a.ContactWebsite, ApprenticeshipLocations = locations.GetValueOrDefault(a.ApprenticeshipId, Enumerable.Empty <ApprenticeshipLocationResult>()) .Select(al => { // Some bad Classroom-based data has a non-null National value; fix that up here if (al.ApprenticeshipLocationType == ApprenticeshipLocationType.ClassroomBased) { al.National = null; } // If National is true then remove explicit Radius if (al.National == true) { al.Radius = null; } return new ApprenticeshipLocation() { ApprenticeshipLocationId = al.ApprenticeshipLocationId, ApprenticeshipLocationType = al.ApprenticeshipLocationType, DeliveryModes = MapDeliveryModesFromSqlValue(al.DeliveryModes).ToArray(), National = al.National, Radius = al.Radius, SubRegionIds = apprenticeshipLocationSubRegions.GetValueOrDefault(al.ApprenticeshipLocationId, Enumerable.Empty <string>()).ToArray(), Telephone = al.Telephone, Venue = al.Venue }; }) .ToArray() }) .ToArray()); }
/// <summary> /// Set data for List result. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="result"></param> /// <returns></returns> protected virtual IEnumerable <T> SetListData(SqlMapper.GridReader result) { return(result.Read <T>()); }
public GridReaderResultReader(SqlMapper.GridReader reader) { _reader = reader; }
private static async Task <Table> GetTableSchemaAsync(this SqlConnection connection, SqlTransaction transaction, TableSchemaKey key, CancellationToken cancellationToken) { // Validate parameters. Debug.Assert(connection != null); // The sql. const string sql = @" select s.name as schema_name, t.name as table_name, t.create_date, t.modify_date from sys.tables as t inner join sys.schemas as s on s.schema_id = t.schema_id where t.object_id = object_id(@table); select c.column_id, c.name, c.is_identity, c.is_nullable, c.is_computed from sys.columns as c where c.object_id = object_id(@table); select i.index_id, i.name, i.is_primary_key, ic.column_id, ic.key_ordinal, ic.is_descending_key, ic.is_included_column from sys.indexes as i inner join sys.index_columns as ic on ic.object_id = i.object_id and ic.index_id = i.index_id where i.object_id = object_id(@table); "; // Query multiple. using (SqlMapper.GridReader gridReader = await connection.QueryMultipleAsync(sql, new { table = key.Table }, transaction: transaction, commandType: CommandType.Text).ConfigureAwait(false)) { // Get the items. TableRecord tableRecord = (await gridReader.ReadAsync <TableRecord>().ConfigureAwait(false)). Single(); // Set the column records. IReadOnlyCollection <ColumnRecord> columnRecords = (await gridReader.ReadAsync <ColumnRecord>(). ConfigureAwait(false)).ToReadOnlyCollection(); // Set the index records. IReadOnlyCollection <IndexRecord> indexRecords = (await gridReader.ReadAsync <IndexRecord>(). ConfigureAwait(false)).ToReadOnlyCollection(); // Start creating everything, the columns first. IReadOnlyDictionary <int, Column> columns = columnRecords. Select(c => new Column(c.column_id, c.name, c.is_identity, c.is_nullable, c.is_computed)). ToReadOnlyDictionary(c => c.Id); // Get the indexes and index columns. IReadOnlyCollection <Index> indexes = indexRecords. // Group the indexes first. GroupBy(i => new { i.index_id, i.name, i.is_primary_key }). // Select the index for each group. Select(g => new Index(g.Key.index_id, g.Key.name, g.Key.is_primary_key, // Get the individual columns. g.Select(c => new IndexColumn(columns[c.column_id], c.key_ordinal, c.is_descending_key, c.is_included_column)))). // Materialize. ToReadOnlyCollection(); // Assemble the table and return. return(new Table(tableRecord.schema_name, tableRecord.table_name, tableRecord.create_date, tableRecord.modify_date, columns.Values.OrderBy(c => c.Id), indexes)); } }
private bool ParseResult(IBookingData request, SqlMapper.GridReader reader) { if ((request == null) || (reader == null)) { return(false); } if (request.Value == null) { return(false); } try { request.OfficeDto = SelectionHelpers.WrappedSelectedDto <OFICINAS, OfficeDtos>(request.Value.OFICINA_RES1, _mapper, reader); request.ReservationOfficeDeparture = SelectionHelpers.WrappedSelectedDto <OFICINAS, OfficeDtos>(request.Value.OFISALIDA_RES1, _mapper, reader); request.ReservationOfficeArrival = SelectionHelpers.WrappedSelectedDto <OFICINAS, OfficeDtos>(request.Value.OFIRETORNO_RES1, _mapper, reader); request.BookingBudget = SelectionHelpers.WrappedSelectedDto <BudgetSummaryDto, BudgetSummaryDto>(request.Value.PRESUPUESTO_RES1, _mapper, reader); request.FareDto = SelectionHelpers.WrappedSelectedDto <NTARI, FareDto>(request.Value.TARIFA_RES1, _mapper, reader); request.VehicleGroupDto = SelectionHelpers.WrappedSelectedDto <GRUPOS, VehicleGroupDto>(request.Value.GRUPO_RES1, _mapper, reader); request.BrokerDto = SelectionHelpers.WrappedSelectedDto <CommissionAgentSummaryDto, CommissionAgentSummaryDto>(request.Value.COMISIO_RES2, _mapper, reader); request.VehicleDto = SelectionHelpers.WrappedSelectedDto <VehicleSummaryDto, VehicleSummaryDto>(request.Value.VCACT_RES1, _mapper, reader); request.Clients = SelectionHelpers.WrappedSelectedDto <ClientSummaryExtended, ClientSummaryExtended>(request.Value.CLIENTE_RES1, _mapper, reader); request.DriverDto2 = SelectionHelpers.WrappedSelectedDto <ClientSummaryExtended, ClientSummaryExtended>(request.Value.CONDUCTOR_RES1, _mapper, reader); request.DriverDto3 = SelectionHelpers.WrappedSelectedDto <ClientSummaryExtended, ClientSummaryExtended>(request.Value.OTROCOND_RES2, _mapper, reader); request.DriverDto4 = SelectionHelpers.WrappedSelectedDto <ClientSummaryExtended, ClientSummaryExtended>(request.Value.OTRO2COND_RES2, _mapper, reader); request.DriverDto5 = SelectionHelpers.WrappedSelectedDto <ClientSummaryExtended, ClientSummaryExtended>(request.Value.OTRO3COND_RES2, _mapper, reader); // request.DriverDto6 = SelectionHelpers.WrappedSelectedDto<ClientSummaryExtended, ClientSummaryExtended>(request.Value., _mapper, reader); request.CityDto3 = SelectionHelpers.WrappedSelectedDto <POBLACIONES, CityDto>(request.Value.POCOND_RES2, _mapper, reader); request.DriverCountryList = SelectionHelpers.WrappedSelectedDto <Country, CountryDto>(request.Value.PAISNIFCOND_RES2, _mapper, reader); request.CountryDto3 = SelectionHelpers.WrappedSelectedDto <Country, CountryDto>(request.Value.PAISCOND_RES2, _mapper, reader); request.ProvinceDto3 = SelectionHelpers.WrappedSelectedDto <PROVINCIA, ProvinciaDto>(request.Value.PROVCOND_RES2, _mapper, reader); request.OriginDto = SelectionHelpers.WrappedSelectedDto <ORIGEN, OrigenDto>(request.Value.ORIGEN_RES2, _mapper, reader); request.BookingMediaDto = SelectionHelpers.WrappedSelectedDto <MEDIO_RES, BookingMediaDto>(request.Value.MEDIO_RES1, _mapper, reader); request.BookingTypeDto = SelectionHelpers.WrappedSelectedDto <TIPOS_RESERVAS, BookingTypeDto>(request.Value.TIPORES_res1, _mapper, reader); request.AgencyEmployeeDto = SelectionHelpers.WrappedSelectedDto <EAGE, AgencyEmployeeDto>(request.Value.EMPLEAGE_RES2, _mapper, reader); request.ContactsDto1 = SelectionHelpers.WrappedSelectedDto <CliContactos, ContactsDto>(request.Value.CONTACTO_RES2, _mapper, reader); request.PaymentFormDto = SelectionHelpers.WrappedSelectedDto <FORMAS, PaymentFormDto>(request.Value.FCOBRO_RES1, _mapper, reader); request.PrintingTypeDto = SelectionHelpers.WrappedSelectedDto <CONTRATIPIMPR, PrintingTypeDto>(request.Value.CONTRATIPIMPR_RES, _mapper, reader); request.VehicleActivitiesDto = SelectionHelpers.WrappedSelectedDto <ACTIVEHI, VehicleActivitiesDto>(request.Value.ACTIVEHI_RES1, _mapper, reader); #pragma warning disable CS0168 // Variable is declared but never used } catch (System.Exception ex) #pragma warning restore CS0168 // Variable is declared but never used { throw new DataAccessLayerException("Parsing multiple query result error", ex); } return(true); }
void mapper(SqlMapper.GridReader gridReader) { results = gridReader.Read <T>(); totalRows = gridReader.Read <int>().First(); }
public async Task <IEnumerable <FarmerBuyingCalendarViewModel> > Gets(string condition = "") { List <FarmerBuyingCalendarViewModel> result = new List <FarmerBuyingCalendarViewModel>(); string cmd = $@"SELECT * FROM `farmer_buying_calendar` o LEFT JOIN `farmer` f ON o.farmer_id = f.id AND f.is_used = 1 AND f.is_deleted = 0 LEFT JOIN `farmer_buying_calendar_item` i ON i.farmer_buying_calendar_id = o.id LEFT JOIN `product` p ON p.id = i.product_id AND p.is_used = 1 AND p.is_deleted = 0 LEFT JOIN `uom` u ON u.id = i.uom_id AND u.is_used = 1 AND u.is_deleted = 0 WHERE o.is_deleted = 0"; if (!string.IsNullOrEmpty(condition)) { cmd += " AND " + condition; } if (DbConnection != null) { SqlMapper.GridReader rd = await DbConnection.QueryMultipleAsync(cmd, transaction : DbTransaction); rd.Read <FarmerBuyingCalendar, Farmer, FarmerBuyingCalendarItem, Product, UoM, FarmerBuyingCalendarViewModel>( (orderRs, fRs, itemRs, pRs, uRs) => { var order = result.FirstOrDefault(o => o.Id == orderRs.Id); if (order == null) { order = CommonHelper.Mapper <FarmerBuyingCalendar, FarmerBuyingCalendarViewModel>(orderRs); result.Add(order); } if (order.Farmer == null) { order.Farmer = fRs; } var item = order.Items.FirstOrDefault(i => i.Id == itemRs.Id); if (item == null) { item = CommonHelper.Mapper <FarmerBuyingCalendarItem, FarmerBuyingCalendarItemViewModel>(itemRs); order.Items.Add(item); } item.Product = pRs; item.UoM = uRs; return(order); } ); return(result); } else { using (var conn = DALHelper.GetConnection()) { SqlMapper.GridReader rd = await conn.QueryMultipleAsync(cmd, transaction : DbTransaction); rd.Read <FarmerBuyingCalendar, Farmer, FarmerBuyingCalendarItem, Product, UoM, FarmerBuyingCalendarViewModel>( (orderRs, fRs, itemRs, pRs, uRs) => { var order = result.FirstOrDefault(o => o.Id == orderRs.Id); if (order == null) { order = CommonHelper.Mapper <FarmerBuyingCalendar, FarmerBuyingCalendarViewModel>(orderRs); result.Add(order); } if (order.Farmer == null) { order.Farmer = fRs; } var item = order.Items.FirstOrDefault(i => i.Id == itemRs.Id); if (item == null) { item = CommonHelper.Mapper <FarmerBuyingCalendarItem, FarmerBuyingCalendarItemViewModel>(itemRs); order.Items.Add(item); } item.Product = pRs; item.UoM = uRs; return(order); } ); return(result); } } }
public QueryReader(SqlMapper.GridReader reader, DbConnection connection) { _reader = reader; _connection = connection; }
public GridReaderWrapper(SqlMapper.GridReader gridReader) { _gridReader = gridReader; }
static IEnumerable <TMain> MapKeys <TMain, TFirstChild, TSecondChild, TThirdChild, TFourthChild, TFifthChild, TSixthChild, TSeventhChild, TEighthChild, TKey> ( SqlMapper.GridReader reader, Func <TMain, TKey> mainKey, Func <TFirstChild, TKey> firstChild, Func <TSecondChild, TKey> secondChild, Func <TThirdChild, TKey> thirdChild, Func <TFourthChild, TKey> fourthChild, Func <TFifthChild, TKey> fifthChild, Func <TSixthChild, TKey> sixthChild, Func <TSeventhChild, TKey> seventhChild, Func <TEighthChild, TKey> eighthChild, Action <TMain, IEnumerable <TFirstChild> > addFirstChild, Action <TMain, IEnumerable <TSecondChild> > addSecondChild, Action <TMain, IEnumerable <TThirdChild> > addThirdChild, Action <TMain, IEnumerable <TFourthChild> > addFourthChild, Action <TMain, IEnumerable <TFifthChild> > addFifthChild, Action <TMain, IEnumerable <TSixthChild> > addSixthChild, Action <TMain, IEnumerable <TSeventhChild> > addSeventhChild, Action <TMain, IEnumerable <TEighthChild> > addEighthChild ) { var first = reader.Read <TMain>().ToList(); var childFirstMap = reader .Read <TFirstChild>() .GroupBy(s => firstChild(s)) .ToDictionary(g => g.Key, g => g.AsEnumerable()); var childSecondMap = reader .Read <TSecondChild>() .GroupBy(s => secondChild(s)) .ToDictionary(g => g.Key, g => g.AsEnumerable()); var childThirdMap = reader .Read <TThirdChild>() .GroupBy(s => thirdChild(s)) .ToDictionary(g => g.Key, g => g.AsEnumerable()); var childFourthMap = reader .Read <TFourthChild>() .GroupBy(s => fourthChild(s)) .ToDictionary(g => g.Key, g => g.AsEnumerable()); var childFifthMap = reader .Read <TFifthChild>() .GroupBy(s => fifthChild(s)) .ToDictionary(g => g.Key, g => g.AsEnumerable()); var childSixthMap = reader .Read <TSixthChild>() .GroupBy(s => sixthChild(s)) .ToDictionary(g => g.Key, g => g.AsEnumerable()); var childSeventhMap = reader .Read <TSeventhChild>() .GroupBy(s => seventhChild(s)) .ToDictionary(g => g.Key, g => g.AsEnumerable()); var childEighthMap = reader .Read <TEighthChild>() .GroupBy(s => eighthChild(s)) .ToDictionary(g => g.Key, g => g.AsEnumerable()); foreach (var item in first) { IEnumerable <TFirstChild> childrenOfFirst; if (childFirstMap.TryGetValue(mainKey(item), out childrenOfFirst)) { addFirstChild(item, childrenOfFirst); } IEnumerable <TSecondChild> childrenOfSecond; if (childSecondMap.TryGetValue(mainKey(item), out childrenOfSecond)) { addSecondChild(item, childrenOfSecond); } IEnumerable <TThirdChild> childrenOfThird; if (childThirdMap.TryGetValue(mainKey(item), out childrenOfThird)) { addThirdChild(item, childrenOfThird); } IEnumerable <TFourthChild> childrenOfFourth; if (childFourthMap.TryGetValue(mainKey(item), out childrenOfFourth)) { addFourthChild(item, childrenOfFourth); } IEnumerable <TFifthChild> childrenOfFifth; if (childFifthMap.TryGetValue(mainKey(item), out childrenOfFifth)) { addFifthChild(item, childrenOfFifth); } IEnumerable <TSixthChild> childrenOfSixth; if (childSixthMap.TryGetValue(mainKey(item), out childrenOfSixth)) { addSixthChild(item, childrenOfSixth); } IEnumerable <TSeventhChild> childrenOfSeventh; if (childSeventhMap.TryGetValue(mainKey(item), out childrenOfSeventh)) { addSeventhChild(item, childrenOfSeventh); } IEnumerable <TEighthChild> childrenOfEighth; if (childEighthMap.TryGetValue(mainKey(item), out childrenOfEighth)) { addEighthChild(item, childrenOfEighth); } } return(first); }
private static async Task <ICollection <TransactionModel> > GetTransactionModelsAsync(SqlMapper.GridReader reader) { var transactions = (await reader.ReadAsync <Transaction>()).ToList(); var postings = await reader.ReadAsync <PostingDto>(); var postingsLookupByTransactionId = postings .GroupBy(x => x.TransactionId) .ToDictionary(x => x.Key, x => x.ToList()); var transactionModels = new List <TransactionModel>(transactions.Count); foreach (var transaction in transactions) { var transactionModel = new TransactionModel { Id = transaction.Id, Description = transaction.Description, PostedDate = transaction.PostedDate, }; if (postingsLookupByTransactionId.TryGetValue(transaction.Id, out var transactionPostings)) { foreach (var posting in transactionPostings) { var postingModel = new TransactionModel.Posting { Account = new TransactionModel.Account { Id = posting.AccountId, Name = posting.AccountName }, Amount = posting.Amount, }; transactionModel.Postings.Add(postingModel); } } transactionModels.Add(transactionModel); } return(transactionModels); }
protected virtual List <T> PageListItems(SqlMapper.GridReader gridReader) { var result = gridReader.Read <T>(); return(result.ToList()); }
public static IEnumerable <DtoType> SelectDto <EntityType, DtoType>(IMapper mapper, SqlMapper.GridReader gridReader) where DtoType : class { var hasValue = gridReader.ReadSingle <int>() > 0; if (hasValue) { var entityCollection = gridReader.Read <EntityType>(); if (entityCollection != null) { if (typeof(EntityType) != typeof(DtoType)) { return(mapper.Map <IEnumerable <EntityType>, IEnumerable <DtoType> >(entityCollection)); } else { return(entityCollection as IEnumerable <DtoType>); } } } else { var badValue = gridReader.Read(); } var list = new List <DtoType>(); return(list); }
public IEnumerable <T> Read <T>() { SqlMapper.GridReader reader = _items.Dequeue(); return(reader.Read <T>()); }
public static IEnumerable <DtoType> WrappedSelectedDto <EntityType, DtoType>(object value, IMapper mapper, SqlMapper.GridReader reader) where DtoType : class { IEnumerable <DtoType> current = new List <DtoType>(); if ((value == null) || (reader == null)) { return(current); } // malformed string or empty string shall return null or empty values. if (value is string currentString) { if (string.IsNullOrEmpty(currentString)) { return(current); } } current = SelectDto <EntityType, DtoType>(mapper, reader); return(current); }
internal Reader(SqlMapper.GridReader reader) => _reader = reader;
public async Task <MalUserLookupResults> GetAnimeListForUserAsync(string user, CancellationToken cancellationToken) { using (NpgsqlConnection conn = new NpgsqlConnection(m_connectionString)) { await conn.OpenAsync(cancellationToken); // ILIKE does a table scan. :( The ideal way of doing a case-insensitive search would be to use the citext // data type, but that's an add-on and not part of a standard Postgres install. // This class is only intended to be used for development anyway. string sql = @" SELECT mal_user.mal_name, mal_user.mal_user_id FROM mal_user WHERE mal_name ILIKE :UserName ORDER BY mal_user_id LIMIT 1; SELECT mal_anime.mal_anime_id, mal_anime.title, mal_anime.mal_anime_type_id, mal_anime.num_episodes, mal_anime.mal_anime_status_id, mal_anime.start_year, mal_anime.start_month, mal_anime.start_day, mal_anime.end_year, mal_anime.end_month, mal_anime.end_day, mal_anime.image_url, mal_list_entry.rating, mal_list_entry.mal_list_entry_status_id, mal_list_entry.num_episodes_watched, mal_list_entry.started_watching_year, mal_list_entry.started_watching_month, mal_list_entry.started_watching_day, mal_list_entry.finished_watching_year, finished_watching_month, finished_watching_day, mal_list_entry.last_mal_update, mal_list.synonyms, mal_list.tags FROM ( SELECT mal_user.mal_user_id AS mal_user_id, mal_anime.mal_anime_id AS mal_anime_id, array_agg(DISTINCT mal_anime_synonym.synonym) AS synonyms, array_agg(DISTINCT mal_list_entry_tag.tag) AS tags FROM mal_user JOIN mal_list_entry ON mal_user.mal_user_id = mal_list_entry.mal_user_id JOIN mal_anime ON mal_list_entry.mal_anime_id = mal_anime.mal_anime_id LEFT OUTER JOIN mal_anime_synonym ON mal_anime.mal_anime_id = mal_anime_synonym.mal_anime_id LEFT OUTER JOIN mal_list_entry_tag ON mal_list_entry.mal_anime_id = mal_list_entry_tag.mal_anime_id AND mal_list_entry.mal_user_id = mal_list_entry_tag.mal_user_id WHERE mal_user.mal_user_id = (SELECT mal_user_id FROM mal_user WHERE mal_name ILIKE :UserName ORDER BY mal_user_id LIMIT 1) GROUP BY mal_user.mal_user_id, mal_anime.mal_anime_id ) AS mal_list JOIN mal_user ON mal_list.mal_user_id = mal_user.mal_user_id JOIN mal_anime ON mal_list.mal_anime_id = mal_anime.mal_anime_id JOIN mal_list_entry ON mal_list.mal_user_id = mal_list_entry.mal_user_id AND mal_list.mal_anime_id = mal_list_entry.mal_anime_id "; int userId; string canonicalUserName = null; List <MyAnimeListEntry> entries = new List <MyAnimeListEntry>(); using (SqlMapper.GridReader results = await conn.QueryMultipleAsync(new CommandDefinition(sql, new { UserName = user }, cancellationToken: cancellationToken))) { User u = (await results.ReadAsync <User>()).FirstOrDefault(); if (u == null) { throw new MalUserNotFoundException(string.Format("No MAL list exists for {0}.", user)); } userId = u.mal_user_id; canonicalUserName = u.mal_name; foreach (UserListEntry dbEntry in await results.ReadAsync <UserListEntry>()) { MalAnimeInfoFromUserLookup animeInfo = new MalAnimeInfoFromUserLookup( animeId: dbEntry.mal_anime_id, title: dbEntry.title, type: (MalAnimeType)dbEntry.mal_anime_type_id, synonyms: dbEntry.synonyms.Where(syn => syn != null).ToList(), status: (MalSeriesStatus)dbEntry.mal_anime_status_id, numEpisodes: dbEntry.num_episodes, startDate: new UncertainDate(year: dbEntry.start_year, month: dbEntry.start_month, day: dbEntry.start_day), endDate: new UncertainDate(year: dbEntry.end_year, month: dbEntry.end_month, day: dbEntry.end_day), imageUrl: dbEntry.image_url ); MyAnimeListEntry entry = new MyAnimeListEntry( score: dbEntry.rating, status: (CompletionStatus)dbEntry.mal_list_entry_status_id, numEpisodesWatched: dbEntry.num_episodes_watched, myStartDate: new UncertainDate(year: dbEntry.started_watching_year, month: dbEntry.started_watching_month, day: dbEntry.started_watching_day), myFinishDate: new UncertainDate(year: dbEntry.finished_watching_year, month: dbEntry.finished_watching_month, day: dbEntry.finished_watching_day), myLastUpdate: dbEntry.last_mal_update, animeInfo: animeInfo, tags: dbEntry.tags.Where(tag => tag != null).ToList() ); entries.Add(entry); } return(new MalUserLookupResults(userId: userId, canonicalUserName: canonicalUserName, animeList: entries)); } } }
public object QuerySingle(string sql, dynamic param = null, IDbTransaction transaction = null, int?commandTimeout = null, CommandType?commandType = null) { SqlMapper.GridReader reader = _mydb.QueryMultiple(sql, param, transaction, commandTimeout, commandType); return(reader.ReadFirst()); }
PanelDatasetCompilerContext ReadContextGrid(ConceptDatasetExecutionRequest request, SqlMapper.GridReader gridReader) { var queryCtx = gridReader.Read <QueryContext>().FirstOrDefault(); var concept = HydratedConceptReader.Read(gridReader).FirstOrDefault(); var pi = request.PanelItem; var panel = new Panel { SubPanels = new List <SubPanel> { new SubPanel { PanelItems = new List <PanelItem> { pi.PanelItem(concept) } } } }; if (request.EarlyBound != null && request.LateBound != null) { panel.DateFilter = new DateBoundary { Start = new DateFilter { Date = (DateTime)request.EarlyBound, DateIncrementType = DateIncrementType.Specific }, End = new DateFilter { Date = (DateTime)request.LateBound, DateIncrementType = DateIncrementType.Specific } }; } return(new PanelDatasetCompilerContext { QueryContext = queryCtx, Panel = panel }); }