public GetResult <IEnumerable <ResponseSessionDisplayInfo> > GetSessionList(SessionFilter filter)
{
var query = FormFilteredSessionQuery(filter);
return(new GetResult <IEnumerable <ResponseSessionDisplayInfo> >
{
ResultOk = true,
RequestedData = query
.Select(s => new ResponseSessionDisplayInfo
{
SessionId = s.SessionId,
Film = new ResponseFilmDisplayInfo
{
FilmId = s.FilmId,
Name = s.Film.Name
},
Cinema = new ResponseCinemaDisplayInfo
{
Name = s.CinemaRoom.Cinema.Name,
City = s.CinemaRoom.Cinema.City,
CinemaId = s.CinemaRoom.Cinema.CinemaId
},
CinemaRoom = new ResponseCinemaRoomDisplayInfo
{
Name = s.CinemaRoom.Name,
CinemaRoomId = s.CinemaRoomId
},
BeginTime = s.BeginTime
})
});
}
public async Task <IActionResult> Sessions([FromRoute] string credentialId, [FromQuery] SessionFilter filter)
{
if (string.IsNullOrEmpty(credentialId))
{
return(NotFound());
}
var validationResult = new SessionFilterValidator(DisplayNameRule).Validate(filter);
validationResult.AddToModelState(this.ModelState, null);
if (!validationResult.IsValid)
{
return(ValidationError());
}
var sessionsPage = await CredentialStore.GetSessions(credentialId, filter);
if (sessionsPage.IsEmpty)
{
return(NotFound <Session>(filter, sessionsPage));
}
return(Collection <Session>(filter, sessionsPage));
}
public async Task <IEnumerable <SessionDto> > FindAsync(SessionFilter filter = null)
{
var sessions = await sessionRepository.FindAsync(filter);
var sessionsDto = mapper.Map <IEnumerable <SessionDto> >(sessions);
return(sessionsDto);
}
public async Task <SessionDto> GetAsync(int id, SessionFilter filter = null)
{
var session = await sessionRepository.GetAsync(id);
var sessionDto = mapper.Map <SessionDto>(session);
return(sessionDto);
}
private bool FilterSpeakers(object obj)
{
if (obj is Session session)
{
return(session.Title.ToUpper().Contains(SessionFilter.ToUpper()) || session.Timeslot_1.ToUpper().Contains(SessionFilter.ToUpper()) ||
session.Room_1.ToUpper().Contains(SessionFilter.ToUpper()) || session.Speaker_1.ToUpper().Contains(SessionFilter.ToUpper()));
}
return(false);
}
public IActionResult GetSessionList([FromQuery] SessionFilter filter)
{
GetResult <IEnumerable <ResponseSessionDisplayInfo> > result = sessionService.GetSessionList(filter);
if (result.ResultOk)
{
return(Ok(result));
}
return(NotFound(result));
}
static void Main(string[] args)
{
var xmlFile = @"C:\Users\dfrin_000\Desktop\local_test.xml";
var username = "******";
var password = "******";
var folderName = "Test";
using (var sessionManager = new SessionManagementWrapper(username, password))
{
var folderId = GetFolderId(folderName, sessionManager);
using (var remoteRecorderService = new RemoteRecorderManagementWrapper(username, password))
{
using (var usageManager = new UsageManagementWrapper(username, password))
{
SessionFilter filter = new SessionFilter();
//usageManager.IsSessionUsageOK();
}
}
}
//try
//{
// var parser = new RecorderScheduleXmlParser(xmlFile);
// var recordings = parser.ExtractRecordings();
// using (var sessionManager = new SessionManagementWrapper(username, password))
// {
// var folderId = GetFolderId(folderName, sessionManager);
// using (var remoteRecorderService = new RemoteRecorderManagementWrapper(username, password))
// {
// //var settings = remoteRecorderService.GetSettingsByRecorderName("EDKNIGHT-PC");
// //remoteRecorderService.ScheduleRecording("TestRecording", folderId, false, DateTime.Now, DateTime.Now.AddMinutes(1), new List<RecorderSettings> { settings });
// foreach (var recording in recordings)
// {
// var settings = remoteRecorderService.GetSettingsByRecorderName(recording.RecorderName);
// remoteRecorderService.ScheduleRecording(recording.Title, folderId, false, recording.StartTime, recording.EndTime, new List<RecorderSettings> { settings }, false);
// }
// }
// }
//}
//catch (Exception e)
//{
// log.Error(e);
// Console.WriteLine("An error has occurred: {0}", e.Message);
// Console.WriteLine("See the log for more details.");
//}
Console.ReadLine();
}
public static List <SessionView> ListSessions(SessionFilter filter)
{
var perculus = Common.CreatePerculusClient();
(List <SessionView> sessions, ApiErrorResponse error) = perculus.Sessions.SearchSessions(filter);
if (error != null)
{
Common.HandleErrorResponse(error);
}
return(sessions);
}
public async Task <ActionResult> Sessions(
[FromRoute] string dateFilter,
[FromRoute] string cinemaFilter,
[FromRoute] string filmFilter)
{
SessionFilter filter = new SessionFilter()
{
SessionDate = Convert.ToDateTime(dateFilter),
CinemaName = cinemaFilter,
FilmName = filmFilter
};
var sessions = await sessionService.FindAsync(filter);
return(View(sessions));
}
public void ApplySessionFilters(SessionFilter filter)
{
if (filter != null)
{
if (filter.Active != null)
{
this.AddParameter("active", filter.Active);
}
if (filter.From != null)
{
this.AddParameter("from", String.Format("{0:dd/MM/yyyy}", filter.From));
}
if (filter.To != null)
{
this.AddParameter("to", String.Format("{0:dd/MM/yyyy}", filter.To));
}
}
}
public Task <Session> GetAsync(int id, SessionFilter filter = null)
{
var session = dbContext.Sessions
.Include(s => s.Tickets)
.SingleOrDefault(s => s.SessionId == id);
ICollection <Ticket> filteredTickets = new Collection <Ticket>();
foreach (var filteredTicket in session.Tickets)
{
if (filteredTicket.OrderId == null)
{
filteredTickets.Add(filteredTicket);
}
}
if (filteredTickets.Count != 0)
{
session.Tickets = filteredTickets;
}
return(Task.FromResult(session));
}
public Task <IEnumerable <Session> > FindAsync(SessionFilter filter = null)
{
if (filter != null)
{
var sessions = dbContext.Sessions
.AsNoTracking()
.Include(s => s.Cinema)
.Include(s => s.Film)
.Where(s => s.SessionDate == filter.SessionDate &&
s.Cinema.Name == filter.CinemaName &&
s.Film.Title == filter.FilmName)
.AsEnumerable();
return(Task.FromResult(sessions));
}
else
{
var sessions = dbContext.Sessions
.AsNoTracking()
.AsEnumerable();
return(Task.FromResult(sessions));
}
}
private IQueryable <Session> FormFilteredSessionQuery(SessionFilter filter)
{
IQueryable <Session> query = dbContext.Sessions
.Include(s => s.Film)
.Include(s => s.CinemaRoom)
.Include(s => s.CinemaRoom.Cinema)
.AsNoTracking();
if (filter.FilmId != null)
{
query = query.Where(s => s.FilmId == filter.FilmId);
}
if (filter.StartDate != null)
{
query = query.Where(s => filter.StartDate < s.BeginTime);
}
if (filter.EndDate != null)
{
query = query.Where(s => s.BeginTime < filter.EndDate);
}
return(query);
}
/// <inheritdoc/>
public virtual async Task DeleteSessionsAsync(SessionFilter filter, CancellationToken cancellationToken = default)
{
cancellationToken = cancellationToken == CancellationToken.None ? CancellationTokenProvider.CancellationToken : cancellationToken;
filter.Validate();
var entities = await Filter(Context.ServerSideSessions.AsQueryable(), filter)
.ToArrayAsync(cancellationToken);
entities = Filter(entities.AsQueryable(), filter).ToArray();
Context.ServerSideSessions.RemoveRange(entities);
try
{
await Context.SaveChangesAsync(cancellationToken);
Logger.LogDebug("Removed {serverSideSessionCount} server-side sessions from database for {@filter}", entities.Length, filter);
}
catch (DbUpdateConcurrencyException ex)
{
Logger.LogInformation("Error removing {serverSideSessionCount} server-side sessions from database for {@filter}: {error}", entities.Length, filter, ex.Message);
}
}
/// <summary>
/// Search Sessions using session filter
/// </summary>
/// <param name="filter">SessionFilter Model</param>
/// <returns>A session view list object and error info if error occurs</returns>
public List <SessionView> SearchSessions(SessionFilter filter, out ApiErrorResponse error)
{
string query = filter.ToQueryString();
var request = HttpWebClient.CreateWebRequest("GET", BuildRoute($"session?{query}"));
var response = HttpWebClient.SendWebRequest(request);
List <SessionView> sessionsViews = null;
error = null;
if (response != null)
{
string result = HttpWebClient.GetResponseBody(response);
if (response.StatusCode == HttpStatusCode.OK)
{
sessionsViews = result.ToObject <List <SessionView> >();
}
else
{
error = response.ToErrorResponse();
}
}
return(sessionsViews);
}
/// <inheritdoc/>
public virtual async Task <IReadOnlyCollection <ServerSideSession> > GetSessionsAsync(SessionFilter filter, CancellationToken cancellationToken = default)
{
cancellationToken = cancellationToken == CancellationToken.None ? CancellationTokenProvider.CancellationToken : cancellationToken;
filter.Validate();
var entities = await Filter(Context.ServerSideSessions.AsNoTracking().AsQueryable(), filter)
.ToArrayAsync(cancellationToken);
entities = Filter(entities.AsQueryable(), filter).ToArray();
var results = entities.Select(entity => new ServerSideSession
{
Key = entity.Key,
Scheme = entity.Scheme,
SubjectId = entity.SubjectId,
SessionId = entity.SessionId,
DisplayName = entity.DisplayName,
Created = entity.Created,
Renewed = entity.Renewed,
Expires = entity.Expires,
Ticket = entity.Data,
}).ToArray();
Logger.LogDebug("Found {serverSideSessionCount} server-side sessions for {@filter}", results.Length, filter);
return(results);
}
static void Main(string[] args)
{
var config = Config.GetInstance();
var userEmail = "test-user-" + Guid.NewGuid() + "@advancity.com.tr";
var username = "******" + Guid.NewGuid();
var userId = String.Empty;
var sessionId = String.Empty;
try
{
#region USERS
HEADER("Creating a user");
userId = UserMethods.CreateUser(userEmail, username);
if (!String.IsNullOrEmpty(userId))
{
OK("Created user {0}", userId);
}
else
{
ERROR("Could not create user");
}
if (!String.IsNullOrEmpty(userId))
{
HEADER("Getting the user");
var user = UserMethods.GetUserById(userId);
if (user != null)
{
OK("Fetched user information by user id: {0}", JsonConvert.SerializeObject(user));
user = UserMethods.GetUserByUsername(user.username);
if (user != null)
{
OK("Fetched user information by username: {0}", JsonConvert.SerializeObject(user));
}
HEADER("Searching users");
List <UserView> users = UserMethods.SearchUsers(new UserFilter()
{
Role = "u",
PageNumber = 1,
PageSize = 3,
UserName = username,
});
OK("{0} Users Found {1}", users.Count.ToString(), JsonConvert.SerializeObject(users));
HEADER("Updating user");
PostUserView updateModel = new PostUserView
{
email = user.email,
username = user.username,
lang = user.lang,
name = user.name,
surname = user.surname,
expires_at = user.expires_at,
role = user.role,
active = user.status == Models.Enum.ActiveStatus.Active ? true : false
};
string updatedUserId = UserMethods.UpdateUser(userId, updateModel);
OK("Updated user {0}", updatedUserId);
}
else
{
ERROR("User could not be fetched.");
}
HEADER("Changing password");
if (UserMethods.ChangeUserPassword(userId, "123"))
{
OK("Changed password");
}
else
{
ERROR("Password could not be changed.");
}
}
#endregion USERS
#region SESSIONS & Attendees
HEADER("Creating a session");
sessionId = SessionMethods.CreateSession();
if (!String.IsNullOrEmpty(sessionId))
{
OK("Created session {0}", sessionId);
}
else
{
ERROR("Could not create session");
}
if (!String.IsNullOrEmpty(sessionId))
{
HEADER("Getting the session");
var session = SessionMethods.GetSession(sessionId);
if (session != null)
{
OK("Fetched session {0}. {1}{2}", session.session_id, Environment.NewLine, JsonConvert.SerializeObject(session));
}
else
{
ERROR("Session could not be updated");
}
}
if (!String.IsNullOrEmpty(sessionId))
{
HEADER("Updating the session");
var session_id_updated = SessionMethods.UpdateSession(sessionId);
if (!String.IsNullOrEmpty(session_id_updated))
{
OK("Updated session {0}", session_id_updated);
}
else
{
ERROR("Session could not be updated");
}
}
HEADER("Search Sessions");
var sessionFilter = new SessionFilter()
{
//SessionName = "SessionName",
BeginDate = DateTime.Now.AddMinutes(-10),
PageNumber = 1,
PageSize = 10
};
var sessionsList = SessionMethods.ListSessions(sessionFilter);
if (sessionsList != null && sessionsList.Count > 0)
{
OK("{0} Sessions Found {1}", sessionsList.Count.ToString(), JsonConvert.SerializeObject(sessionsList));
}
else
{
ERROR("Sessions could not be found");
}
if (!String.IsNullOrEmpty(userId) && !String.IsNullOrEmpty(sessionId))
{
HEADER("Adding attendee by user id {0} to session {1}", userId, sessionId);
if (AttendeeMethods.AddAttendeeByUserId(sessionId, userId) != null)
{
OK("Created attendee");
}
else
{
ERROR("Could not create attendee");
}
HEADER("Searching for an attendee in session {0}", sessionId);
var attendeeSearchFilter = new AttendeeFilter()
{
UserId = userId,
Role = "a",
PageSize = 10,
PageNumber = 1
};
var attendees = AttendeeMethods.SearchAttendees(sessionId, attendeeSearchFilter);
if (attendees != null && attendees.Count > 0)
{
OK("{0} Attendees Found: {1}", attendees.Count.ToString(), JsonConvert.SerializeObject(attendees));
}
else
{
ERROR("Attendee Not Found");
}
HEADER("Deleting the attendee by user id");
if (AttendeeMethods.DeleteAttendee(sessionId, userId))
{
OK("Deleted attendee");
}
else
{
ERROR("Could not delete attendee");
}
HEADER("Adding attendee by user id {0} to session {1} using multiple adding method", userId, sessionId);
AttendeesPostResult testMultipleAttendeesByUserId = AttendeeMethods.AddMultipleAttendeesByUserId(sessionId, userId);
if (testMultipleAttendeesByUserId.approved != null && testMultipleAttendeesByUserId.approved.Count == 1)
{
OK("Created attendee");
var attendanceCode = testMultipleAttendeesByUserId.approved[0].attendance_code;
HEADER("Deleting the newly created attendee {0}", attendanceCode);
if (AttendeeMethods.DeleteAttendee(sessionId, attendanceCode))
{
OK("Deleted attendee");
}
else
{
ERROR("Could not delete attendee");
}
}
else
{
ERROR("Could not create attendee");
}
}
if (!String.IsNullOrEmpty(sessionId))
{
HEADER("Adding external attendee (without user id)");
var newAttendee = new PostAttendeeView()
{
name = "Test Attendee Name",
surname = "Test Attendee Surname",
email = userEmail,
mobile = "05412345678",
role = "u",
};
AttendeeView testAddAttendee = AttendeeMethods.AddAttendee(sessionId, newAttendee);
if (testAddAttendee != null)
{
string joiningAddress = string.Format(config.APP_JOIN_URL_FORMAT, testAddAttendee.attendance_code);
OK("Created attendee -> Join address: {0}", joiningAddress);
HEADER("Deleting newly created attendee {0}", testAddAttendee.attendance_code);
if (AttendeeMethods.DeleteAttendee(sessionId, testAddAttendee.attendance_code))
{
OK("Deleted attendee");
}
else
{
ERROR("Could not delete attendee");
}
}
}
#endregion SESSIONS
}
catch (Exception ex)
{
Console.WriteLine("Exception occured. Details: " + Environment.NewLine + ex.ToString());
}
try
{
#region Clean-UP
HEADER("CLEAN-UP");
if (!String.IsNullOrEmpty(userId))
{
if (UserMethods.DeleteUser(userId))
{
OK("Deleted user {0}", userId);
}
else
{
ERROR("Could not delete user {0}", userId);
}
}
if (!String.IsNullOrEmpty(sessionId))
{
if (SessionMethods.DeleteSession(sessionId))
{
OK("Deleted session {0}", sessionId);
}
else
{
ERROR("Could not delete session {0}", sessionId);
}
}
#endregion Clean-UP
}
catch (Exception ex)
{
Console.WriteLine("Exception occured. Details: " + Environment.NewLine + ex.ToString());
}
HEADER("THE END");
Console.ReadKey();
}
/// <inheritdoc/>
public async Task <IReadOnlyCollection <UserSession> > GetSessionsAsync(SessionFilter filter, CancellationToken cancellationToken = default)
{
var sessions = await _store.GetSessionsAsync(filter, cancellationToken);
var results = sessions
.Select(x => new { x.Renewed, Ticket = x.Deserialize(_protector, _logger) ! })
private void SetUp()
{
SetUpGenericRepositoryStub();
_filter = new SessionFilter(_genericRepository);
}
/// <summary>
/// Retrieves a list of sessions. This endpoint implements pagination by using links. Additionally, it is possible to filter by parameters such as patientId, externalId, createdAfter, updatedAfter or to sort ascending or descending.
/// </summary>
/// <exception cref="CNXT.Connector.Client.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="first">Read the first n sessions of the set. The default and maximum value is set to 25 sessions per request.</param>
/// <param name="after">Read all sessions in the set after (below) this cursor. (optional)</param>
/// <param name="filter">Filter session by parameters e.g. patientId, externalId, state, createdAfter, or updatedAfter. CreatedAfter is used for filtering sessions which are created after a specified date. UpdatedAfter is used for filtering sessions which are updated after a specified date. (Supported values: patientId, externalId, createdAfter, updatedAfter, state). A state has the following supported values: (OPEN, CLOSED, ORDERED, EXPORTED, SAVED) (optional)</param>
/// <param name="sort">List of parameters to sort sessions by parameter. (Supported values: createdAt, updatedAt). To sort descending add a '-' as prefix e.g. (-createdAt, -updatedAt). (optional)</param>
/// <param name="include">List of related resources for including relationships directly into session such as Patient. (Supported values: patient) (optional)</param>
/// <returns>ApiResponse of SessionsResponse</returns>
public ApiResponse <SessionsResponse> GetSessionsWithHttpInfo(int first, string after = default(string), SessionFilter filter = default(SessionFilter), List <string> sort = default(List <string>), List <string> include = default(List <string>))
{
// verify the required parameter 'first' is set
if (first == null)
{
throw new ApiException(400, "Missing required parameter 'first' when calling SessionsApi->GetSessions");
}
var localVarPath = "/sessions";
var localVarPathParams = new Dictionary <String, String>();
var localVarQueryParams = new List <KeyValuePair <String, String> >();
var localVarHeaderParams = new Dictionary <String, String>(this.Configuration.DefaultHeader);
var localVarFormParams = new Dictionary <String, String>();
var localVarFileParams = new Dictionary <String, FileParameter>();
Object localVarPostBody = null;
// to determine the Content-Type header
String[] localVarHttpContentTypes = new String[] {
};
String localVarHttpContentType = this.Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);
// to determine the Accept header
String[] localVarHttpHeaderAccepts = new String[] {
"application/json"
};
String localVarHttpHeaderAccept = this.Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
if (localVarHttpHeaderAccept != null)
{
localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
}
if (first != null)
{
localVarQueryParams.AddRange(this.Configuration.ApiClient.ParameterToKeyValuePairs("", "first", first)); // query parameter
}
if (after != null)
{
localVarQueryParams.AddRange(this.Configuration.ApiClient.ParameterToKeyValuePairs("", "after", after)); // query parameter
}
// TODO: Bugfix for supporting deepObjects as query parameters
//if (filter != null) localVarQueryParams.AddRange(this.Configuration.ApiClient.ParameterToKeyValuePairs("", "filter", filter)); // query parameter
if (filter != null)
{
foreach (PropertyInfo propertyInfo in filter.GetType().GetProperties().Where(property => property.GetValue(filter, null) != null))
{
if (propertyInfo.PropertyType == typeof(DateTime) || propertyInfo.PropertyType == typeof(DateTime?))
{
DateTime?dateTimeValue = propertyInfo.GetValue(filter, null) as DateTime?;
if (dateTimeValue.HasValue)
{
localVarQueryParams.Add(new KeyValuePair <string, string>(string.Format("filter[{0}]", char.ToLower(propertyInfo.Name[0]) + propertyInfo.Name.Substring(1)), dateTimeValue.Value.ToString("o")));
}
}
else
{
localVarQueryParams.Add(new KeyValuePair <string, string>(string.Format("filter[{0}]", char.ToLower(propertyInfo.Name[0]) + propertyInfo.Name.Substring(1)), propertyInfo.GetValue(filter, null).ToString()));
}
}
}
if (sort != null)
{
localVarQueryParams.AddRange(this.Configuration.ApiClient.ParameterToKeyValuePairs("csv", "sort", sort)); // query parameter
}
if (include != null)
{
localVarQueryParams.AddRange(this.Configuration.ApiClient.ParameterToKeyValuePairs("csv", "include", include)); // query parameter
}
// make the HTTP request
IRestResponse localVarResponse = (IRestResponse)this.Configuration.ApiClient.CallApi(localVarPath,
Method.GET, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams, localVarFileParams,
localVarPathParams, localVarHttpContentType);
int localVarStatusCode = (int)localVarResponse.StatusCode;
if (ExceptionFactory != null)
{
Exception exception = ExceptionFactory("GetSessions", localVarResponse);
if (exception != null)
{
throw exception;
}
}
return(new ApiResponse <SessionsResponse>(localVarStatusCode,
localVarResponse.Headers.ToDictionary(x => x.Name, x => string.Join(",", x.Value)),
(SessionsResponse)this.Configuration.ApiClient.Deserialize(localVarResponse, typeof(SessionsResponse))));
}
public static Dictionary <Session, SessionUsage> FetchSessions(string username, string password, SessionFilter filter)
{
Dictionary <Session, SessionUsage> retSessions = new Dictionary <Session, SessionUsage>();
using (var sessionManager = new SessionManagementWrapper(username, password))
{
Session[] results = sessionManager.GetSessionsInDateRange(filter.StartDate.Value, filter.EndDate.Value);
using (var usageManager = new UsageManagementWrapper(username, password))
{
foreach (var session in results)
{
var usage = usageManager.IsSessionUsageOK(session, filter);
if (!usage.IsOK)
{
retSessions.Add(session, usage);
}
}
}
}
return(retSessions);
}
private IQueryable <Entities.ServerSideSession> Filter(IQueryable <Entities.ServerSideSession> query, SessionFilter filter)
{
if (!String.IsNullOrWhiteSpace(filter.SubjectId))
{
query = query.Where(x => x.SubjectId == filter.SubjectId);
}
if (!String.IsNullOrWhiteSpace(filter.SessionId))
{
query = query.Where(x => x.SessionId == filter.SessionId);
}
return(query);
}
/// <summary>
/// Retrieves a list of sessions. This endpoint implements pagination by using links. Additionally, it is possible to filter by parameters such as patientId, externalId, createdAfter, updatedAfter or to sort ascending or descending.
/// </summary>
/// <exception cref="CNXT.Connector.Client.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="first">Read the first n sessions of the set. The default and maximum value is set to 25 sessions per request.</param>
/// <param name="after">Read all sessions in the set after (below) this cursor. (optional)</param>
/// <param name="filter">Filter session by parameters e.g. patientId, externalId, state, createdAfter, or updatedAfter. CreatedAfter is used for filtering sessions which are created after a specified date. UpdatedAfter is used for filtering sessions which are updated after a specified date. (Supported values: patientId, externalId, createdAfter, updatedAfter, state). A state has the following supported values: (OPEN, CLOSED, ORDERED, EXPORTED, SAVED) (optional)</param>
/// <param name="sort">List of parameters to sort sessions by parameter. (Supported values: createdAt, updatedAt). To sort descending add a '-' as prefix e.g. (-createdAt, -updatedAt). (optional)</param>
/// <param name="include">List of related resources for including relationships directly into session such as Patient. (Supported values: patient) (optional)</param>
/// <returns>SessionsResponse</returns>
public SessionsResponse GetSessions(int first, string after = default(string), SessionFilter filter = default(SessionFilter), List <string> sort = default(List <string>), List <string> include = default(List <string>))
{
ApiResponse <SessionsResponse> localVarResponse = GetSessionsWithHttpInfo(first, after, filter, sort, include);
return(localVarResponse.Data);
}
/// <summary> /// Specify The session conditions. /// </summary> /// <param name="sessionFilter">The session filter.</param> /// <returns>Composed TimeSale</returns> public IIntervalBuilder WithSession(SessionFilter sessionFilter) => Build(cmd => cmd.SessionFilter = sessionFilter);