public async Task <ActionResult> List(int?groupId, int offset = 0, int limit = 10)
{
IEnumerable <Contact> contacts;
SqlQuery query;
if (groupId.HasValue)
{
query = new SqlQuery
{
Offset = offset,
Limit = limit,
Filter = "contact_group_id = " + groupId,
Related = "contact_by_contact_id,contact_group_by_contact_group_id",
IncludeCount = true
};
DatabaseResourceWrapper <ContactContactGroup> result = await databaseApi.GetRecordsAsync <ContactContactGroup>("contact_group_relationship", query);
contacts = result.Records.Select(x => x.Contact);
ViewBag.TotalResults = result.Meta.Count;
if (result.Records.Any())
{
ViewBag.GroupName = result.Records.Select(x => x.ContactGroup.Name).FirstOrDefault();
}
else
{
query = new SqlQuery
{
Filter = "id = " + groupId
};
DatabaseResourceWrapper <ContactGroup> contactGroupResult = await databaseApi.GetRecordsAsync <ContactGroup>("contact_group", query);
ViewBag.GroupName = contactGroupResult.Records.Select(x => x.Name).FirstOrDefault();
}
}
else
{
query = new SqlQuery
{
Offset = offset,
Limit = limit,
IncludeCount = true
};
DatabaseResourceWrapper <Contact> result = await databaseApi.GetRecordsAsync <Contact>("contact", query);
contacts = result.Records;
ViewBag.TotalResults = result.Meta.Count;
}
ViewBag.Page = offset / limit + 1;
ViewBag.PageSize = limit;
return(View(contacts));
}
public void ShouldReturnMetadataWhenQueryingRecordsAsync()
{
// Arrange
IDatabaseApi databaseApi = CreateDatabaseApi();
SqlQuery query = new SqlQuery {
Fields = "*", IncludeCount = true, IncludeSchema = true
};
// Act
DatabaseResourceWrapper <StaffRecord> result = databaseApi.GetRecordsAsync <StaffRecord>("staff", query).Result;
// Assert
result.Meta.ShouldNotBe(null);
result.Meta.Count.ShouldBe(3);
result.Meta.Schema.ShouldNotBe(null);
}
public async Task <ActionResult> List(int offset = 0, int limit = 10)
{
SqlQuery query = new SqlQuery
{
Offset = offset,
Limit = limit,
IncludeCount = true
};
DatabaseResourceWrapper <ContactGroup> result = await databaseApi.GetRecordsAsync <ContactGroup>("contact_group", query);
ViewBag.Page = offset / limit + 1;
ViewBag.PageSize = limit;
ViewBag.TotalResults = result.Meta.Count;
return(View(result.Records));
}
/// <summary>
/// Execute a delete request on specified IDs of a given resource.
/// </summary>
/// <typeparam name="TResponse">Type of the objects included in response.</typeparam>
/// <param name="resource">Resource of the ids that will be deleted.</param>
/// <param name="query">Query parameters.</param>
/// <param name="force">Indicator whether all records should be deleted.</param>
/// <param name="ids">IDs that should be deleted.</param>
/// <returns>A collection of TResponse objects.</returns>
/// <exception cref="ArgumentException">Thrown when ids argument is null or the length of an array is less than 1.</exception>
/// <exception cref="ArgumentNullException">Thrown when any of the required arguments are null.</exception>
internal async Task <IEnumerable <TResponse> > RequestDeleteAsync <TResponse>(string resource, SqlQuery query, bool force, params int[] ids)
where TResponse : class, new()
{
if (resource == null)
{
throw new ArgumentNullException("resource");
}
if (ids == null || ids.Length < 1)
{
throw new ArgumentException("At least one identifier must be specified", "ids");
}
query.CustomParameters.Add("force", force);
query.CustomParameters.Add("ids", string.Join(",", ids));
DatabaseResourceWrapper <TResponse> response = await GetDeserializedResponse <DatabaseResourceWrapper <TResponse> >(
method : HttpMethod.Delete,
resourceParts : new[] { resource },
query : query
);
return(response.Records);
}
/// <summary>
/// Execute a request with specified resource and payload that is a collection.
/// </summary>
/// <typeparam name="TRequest">Type of the request payload</typeparam>
/// <typeparam name="TResponse">Type of the objects included in response.</typeparam>
/// <param name="method">HttpMethod to be used in request.</param>
/// <param name="resource">Resource.</param>
/// <param name="query">Query parameters.</param>
/// <param name="payload">Collection of records that should sent as payload.</param>
/// <returns>A collection of TResponse objects.</returns>
/// <exception cref="ArgumentNullException">Thrown when any of the required arguments are null.</exception>
/// <exception cref="ArgumentException">Thrown when records collection is null or its length is less than 1.</exception>
internal async Task <IEnumerable <TResponse> > RequestWithPayloadAsync <TRequest, TResponse>(HttpMethod method, string resource, SqlQuery query, params TRequest[] payload)
where TRequest : IRecord
{
if (resource == null)
{
throw new ArgumentNullException("resource");
}
if (payload == null || payload.Length < 1)
{
throw new ArgumentException("At least one parameter must be specified", "payload");
}
DatabaseResourceWrapper <TResponse> response = await RequestWithPayloadAsync <RequestResourceWrapper <TRequest>, DatabaseResourceWrapper <TResponse> >(
method : method,
resource : resource,
query : query,
payload : new RequestResourceWrapper <TRequest> {
Records = new List <TRequest>(payload), Ids = payload.Select(x => x.Id).ToArray()
}
);
return(response.Records);
}
