// ReSharper disable PossibleMultipleEnumeration
public async Task RunAsync(IRestContext context)
{
ISystemApi systemApi = context.Factory.CreateSystemApi();
SqlQuery query = new SqlQuery { fields = "*", related = "apps,users,services" };
IEnumerable<RoleResponse> roles = await systemApi.GetRolesAsync(query);
Console.WriteLine("GetRolesAsync(): {0}", roles.Select(x => x.name).ToStringList());
RoleResponse role = roles.SingleOrDefault(x => x.name == NewRole);
if (role != null)
{
await DeleteRole(role, systemApi);
}
RoleRequest newRole = new RoleRequest
{
name = NewRole,
description = "new role",
is_active = true
};
roles = await systemApi.CreateRolesAsync(new SqlQuery(), newRole);
role = roles.Single(x => x.name == NewRole);
Console.WriteLine("CreateRolesAsync(): {0}", context.ContentSerializer.Serialize(role));
newRole.id = role.id;
newRole.description = "new description";
role = (await systemApi.UpdateRolesAsync(new SqlQuery(), newRole)).Single(x => x.name == NewRole);
Console.WriteLine("UpdateUsersAsync(): new description={0}", role.description);
await DeleteRole(role, systemApi);
}
public Task<FolderResponse> UploadFolderAsync(string path, string url, bool clean)
{
if (path == null)
{
throw new ArgumentNullException("path");
}
if (url == null)
{
throw new ArgumentNullException("url");
}
HttpUtils.CheckUrlString(url);
SqlQuery query = new SqlQuery { Fields = null };
query.CustomParameters.Add("extract", true);
query.CustomParameters.Add("clean", clean);
query.CustomParameters.Add("url", url);
return base.RequestAsync<FolderResponse>(
method: HttpMethod.Post,
resource: path,
resourceIdentifier: string.Empty,
query: query
);
}
public async Task<ActionResult> Edit(int id, string returnUrl)
{
SqlQuery contactInfoQuery = new SqlQuery
{
Filter = "id = " + id,
Related = "contact_by_contact_id"
};
ContactInfo contactInfo = (await databaseApi.GetRecordsAsync<ContactInfo>("contact_info", contactInfoQuery)).Records.FirstOrDefault();
if (contactInfo == null)
{
return Redirect(returnUrl);
}
ContactInfoViewModel model = new ContactInfoViewModel
{
InfoType = (InfoType)Enum.Parse(typeof(InfoType), contactInfo.InfoType, true),
ContactInfo = contactInfo,
ContactName = string.Format("{0} {1}", contactInfo.Contact.FirstName, contactInfo.Contact.LastName),
ReturnUrl = returnUrl
};
return View(model);
}
// ReSharper disable PossibleMultipleEnumeration
public async Task RunAsync(IRestContext context)
{
ISystemApi systemApi = context.Factory.CreateSystemApi();
// Read
SqlQuery query = new SqlQuery { fields = "*", related = "services,roles", };
IEnumerable<AppResponse> apps = await systemApi.GetAppsAsync(query);
Console.WriteLine("Apps: {0}", apps.Select(x => x.api_name).ToStringList());
// Cloning
AppResponse todoApp = apps.Single(x => x.api_name == "todoangular");
AppRequest todoAppRequest = todoApp.Convert<AppResponse, AppRequest>();
todoAppRequest.name = todoApp.name + "clone";
todoAppRequest.api_name = todoApp.api_name + "clone";
// Creating a clone
apps = await systemApi.CreateAppsAsync(new SqlQuery(), todoAppRequest);
AppResponse todoAppClone = apps.Single(x => x.api_name == "todoangularclone");
Console.WriteLine("Created a clone app={0}", todoAppClone.api_name);
// Deleting the clone
Debug.Assert(todoAppClone.id.HasValue);
await systemApi.DeleteAppsAsync(true, todoAppClone.id.Value);
Console.WriteLine("Created clone has been deleted");
}
public async Task RunAsync(IRestContext context)
{
ISystemAppApi appApi = context.Factory.CreateSystemAppApi();
// Read
SqlQuery query = new SqlQuery {
Fields = "*",
Related = String.Join(",", RelatedResources.App.StorageService, RelatedResources.App.Roles)
};
IEnumerable<AppResponse> apps = (await appApi.GetAppsAsync(query)).ToList();
Console.WriteLine("Apps:");
foreach (AppResponse app in apps)
{
Console.WriteLine("\tName: {0}, ApiKey: {1}", app.Name, app.ApiKey);
}
// Cloning
AppResponse adminApp = apps.Single(x => x.Name == "admin");
AppRequest adminAppRequest = adminApp.Convert<AppResponse, AppRequest>();
adminAppRequest.Id = null;
adminAppRequest.Name = adminApp.Name + "clone";
// Creating a clone
apps = await appApi.CreateAppsAsync(new SqlQuery(), adminAppRequest);
AppResponse adminAppClone = apps.Single(x => x.Name == "adminclone");
Console.WriteLine("Created a clone app Name:{0}, ApiKey:{1}", adminAppClone.Name, adminAppClone.ApiKey);
// Deleting the clone
Debug.Assert(adminAppClone.Id.HasValue);
await appApi.DeleteAppsAsync(new SqlQuery(), adminAppClone.Id.Value);
Console.WriteLine("Created clone has been deleted");
}
// ReSharper disable PossibleMultipleEnumeration
public async Task RunAsync(IRestContext context)
{
ISystemApi systemApi = context.Factory.CreateSystemApi();
IEnumerable<DeviceResponse> devices = await systemApi.GetDevicesAsync(new SqlQuery());
await DeleteAnyDevices(devices, systemApi);
IUserApi userApi = context.Factory.CreateUserApi();
DeviceRequest device = new DeviceRequest
{
uuid = "1",
model = "model",
platform = "windows",
version = "1.0"
};
bool ok = await userApi.SetDeviceAsync(device);
Console.WriteLine("SetDeviceAsync(): success={0}", ok);
SqlQuery query = new SqlQuery { filter = "platform=\"windows\"", fields = "*" };
devices = await systemApi.GetDevicesAsync(query);
Console.WriteLine("GetDevicesAsync(): {0}", context.ContentSerializer.Serialize(devices.Single()));
await DeleteAnyDevices(devices, systemApi);
}
public async Task<bool> CompletePasswordResetAsync(string email, string newPassword, string code, string answer)
{
if (email == null)
{
throw new ArgumentNullException("email");
}
if (newPassword == null)
{
throw new ArgumentNullException("newPassword");
}
if (code != null && answer != null)
{
throw new ArgumentException("You must specify either code or answer parameters but not both.", "answer");
}
SqlQuery query = new SqlQuery { Fields = null };
query.CustomParameters.Add("login", true);
PasswordResponse response = await base.RequestWithPayloadAsync<PasswordRequest, PasswordResponse>(
method: HttpMethod.Post,
resource: "password",
query: query,
payload: new PasswordRequest { Email = email, NewPassword = newPassword, Code = code, SecurityAnswer = answer }
);
if (response.Success ?? false)
{
Session session = await GetSessionAsync();
base.BaseHeaders.AddOrUpdate(HttpHeaders.DreamFactorySessionTokenHeader, session.SessionId);
}
return response.Success ?? false;
}
public async Task RunAsync(IRestContext context)
{
// Getting database interface
IDatabaseApi databaseApi = context.Factory.CreateDatabaseApi(ServiceName);
// List available tables
IEnumerable<TableInfo> tables = (await databaseApi.GetTableNamesAsync(true)).ToList();
Console.WriteLine("Existing tables: {0}", tables.Select(x => x.Name).ToStringList());
foreach (TableInfo table in tables)
{
Console.WriteLine("\t{0}", table.Name);
}
// Delete staff table if it exists
if (tables.Any(x => x.Name == TableName))
{
Console.WriteLine("Deleting table {0}...", TableName);
if (await databaseApi.DeleteTableAsync(TableName))
{
Console.WriteLine("Table deleted.");
}
}
Console.WriteLine("Creating {0} table schema...", TableName);
TableSchema staffTableSchema = CreateTestTableSchema();
await databaseApi.CreateTableAsync(staffTableSchema);
// Describe table
staffTableSchema = await databaseApi.DescribeTableAsync(TableName);
Console.WriteLine("Got {0} table schema, table's label is {1}", TableName, staffTableSchema.Label);
// Create new record
Console.WriteLine("Creating {0} records...", TableName);
List<StaffRecord> records = CreateStaffRecords().ToList();
records = (await databaseApi.CreateRecordsAsync(TableName, records, new SqlQuery())).Records;
// Update record
Console.WriteLine("Updating {0} records...", TableName);
StaffRecord firstRecord = records.First();
firstRecord.FirstName = "Andrei 2";
await databaseApi.UpdateRecordsAsync(TableName, records, new SqlQuery());
SqlQuery query = new SqlQuery { Filter = "Age > 30", Order = "Age", Fields = "*" };
IEnumerable<StaffRecord> selection = (await databaseApi.GetRecordsAsync<StaffRecord>(TableName, query)).Records;
string ages = selection.Select(x => x.Age.ToString(CultureInfo.InvariantCulture)).ToStringList();
Console.WriteLine("Get records with SqlQuery: ages={0}", ages);
// Deleting one record
Console.WriteLine("Deleting second record...");
await databaseApi.DeleteRecordsAsync(TableName, records.Skip(1).Take(1), new SqlQuery());
// Get table records
records = (await databaseApi.GetRecordsAsync<StaffRecord>(TableName, new SqlQuery())).Records;
Console.WriteLine("Retrieved {0} records:", TableName);
foreach (StaffRecord item in records)
{
Console.WriteLine("\t{0}", item);
}
}
public Task<ResourceWrapper<CustomResponse>> GetCustomSettingsAsync(SqlQuery query = null)
{
return base.RequestAsync<ResourceWrapper<CustomResponse>>(
method: HttpMethod.Get,
resource: "custom",
query: query
);
}
public Task<IEnumerable<ServiceResponse>> UpdateServicesAsync(SqlQuery query, params ServiceRequest[] services)
{
return base.RequestWithPayloadAsync<ServiceRequest, ServiceResponse>(
method: HttpMethod.Patch,
resource: "service",
query: query,
payload: services
);
}
public Task<IEnumerable<LookupResponse>> UpdateLookupsAsync(SqlQuery query, params LookupRequest[] Lookups)
{
return base.RequestWithPayloadAsync<LookupRequest, LookupResponse>(
method: HttpMethod.Patch,
resource: "lookup",
query: query,
payload: Lookups
);
}
public Task<IEnumerable<EmailTemplateResponse>> DeleteEmailTemplatesAsync(SqlQuery query, params int[] ids)
{
return base.RequestDeleteAsync<EmailTemplateResponse>(
resource: "email_template",
query: query,
force: false,
ids: ids
);
}
public Task<IEnumerable<RoleResponse>> UpdateRolesAsync(SqlQuery query, params RoleRequest[] roles)
{
return base.RequestWithPayloadAsync<RoleRequest, RoleResponse>(
method: HttpMethod.Patch,
resource: "role",
query: query,
payload: roles
);
}
public Task<IEnumerable<UserResponse>> UpdateUsersAsync(SqlQuery query, params UserRequest[] users)
{
return base.RequestWithPayloadAsync<UserRequest, UserResponse>(
method: HttpMethod.Patch,
resource: "user",
query: query,
payload: users
);
}
public Task<IEnumerable<CorsResponse>> UpdateCorsAsync(SqlQuery query, params CorsRequest[] templates)
{
return base.RequestWithPayloadAsync<CorsRequest, CorsResponse>(
method: HttpMethod.Patch,
resource: "cors",
query: query,
payload: templates
);
}
public Task<IEnumerable<EmailTemplateResponse>> UpdateEmailTemplatesAsync(SqlQuery query, params EmailTemplateRequest[] templates)
{
return base.RequestWithPayloadAsync<EmailTemplateRequest, EmailTemplateResponse>(
method: HttpMethod.Patch,
resource: "email_template",
query: query,
payload: templates
);
}
public Task<IEnumerable<AppResponse>> UpdateAppsAsync(SqlQuery query, params AppRequest[] apps)
{
return base.RequestWithPayloadAsync<AppRequest, AppResponse>(
method: HttpMethod.Patch,
resource: "app",
query: query,
payload: apps
);
}
public Task<IEnumerable<AppResponse>> DeleteAppsAsync(SqlQuery query, params int[] ids)
{
return base.RequestDeleteAsync<AppResponse>(
resource: "app",
query: query,
force: false,
ids: ids
);
}
public Task<IEnumerable<ServiceResponse>> DeleteServicesAsync(SqlQuery query, params int[] ids)
{
return base.RequestDeleteAsync<ServiceResponse>(
resource: "service",
query: query,
force: false,
ids: ids
);
}
public Task<ResourceWrapper<CustomResponse>> UpdateCustomSettingsAsync(List<CustomRequest> customs, SqlQuery query = null)
{
return base.RequestWithPayloadAsync<RequestResourceWrapper<CustomRequest>, ResourceWrapper<CustomResponse>>(
method: HttpMethod.Patch,
resource: "custom",
query: query,
payload: new RequestResourceWrapper<CustomRequest> { Records = customs, Ids = customs.Select((item, index) => (int?)index).ToArray() }
);
}
public Task<EventScriptResponse> DeleteEventScriptAsync(string eventName, SqlQuery query)
{
return base.RequestAsync<EventScriptResponse>(
method: HttpMethod.Delete,
resource: "event",
resourceIdentifier: eventName,
query: query
);
}
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 async Task<IEnumerable<EmailTemplateResponse>> GetEmailTemplatesAsync(SqlQuery query)
{
ResourceWrapper<EmailTemplateResponse> response = await base.RequestAsync<ResourceWrapper<EmailTemplateResponse>>(
method: HttpMethod.Get,
resource: "email_template",
query: query
);
return response.Records;
}
public Task<EventScriptResponse> CreateEventScriptAsync(string eventName, SqlQuery query, EventScriptRequest eventScript)
{
return base.RequestWithPayloadAsync<EventScriptRequest, EventScriptResponse>(
method: HttpMethod.Post,
resource: "event",
resourceIdentifier: eventName,
query: query,
payload: eventScript
);
}
public async Task<IEnumerable<AppResponse>> GetAppsAsync(SqlQuery query)
{
ResourceWrapper<AppResponse> response = await base.RequestAsync<ResourceWrapper<AppResponse>>(
method: HttpMethod.Get,
resource: "app",
query: query
);
return response.Records;
}
public async Task<IEnumerable<ScriptTypeResponse>> GetScriptTypesAsync(SqlQuery query)
{
ResourceWrapper<ScriptTypeResponse> response = await base.RequestAsync<ResourceWrapper<ScriptTypeResponse>>(
method: HttpMethod.Get,
resource: "script_type",
query: query
);
return response.Records;
}
public static IHttpAddress WithSqlQuery(this IHttpAddress httpAddress, SqlQuery query)
{
if (query == null)
{
throw new ArgumentNullException("query");
}
if (query.ids != null)
{
httpAddress = httpAddress.WithParameter("ids", query.ids);
}
if (query.filter != null)
{
httpAddress = httpAddress.WithParameter("filter", query.filter);
}
if (query.order != null)
{
httpAddress = httpAddress.WithParameter("order", query.order);
}
if (query.offset.HasValue)
{
httpAddress = httpAddress.WithParameter("offset", query.offset.Value);
}
if (query.limit.HasValue)
{
httpAddress = httpAddress.WithParameter("limit", query.limit.Value);
}
if (query.fields != null)
{
httpAddress = httpAddress.WithParameter("fields", query.fields);
}
if (query.related != null)
{
httpAddress = httpAddress.WithParameter("related", query.related);
}
if ([email protected])
{
httpAddress = httpAddress.WithParameter("continue", query.@continue);
}
if (query.rollback.HasValue)
{
httpAddress = httpAddress.WithParameter("rollback", query.rollback);
}
return httpAddress;
}
public async Task<IEnumerable<TableInfo>> GetAccessComponentsAsync()
{
SqlQuery query = new SqlQuery { Fields = null };
query.CustomParameters.Add("as_list", true);
ResourceWrapper<TableInfo> response = await base.RequestAsync<ResourceWrapper<TableInfo>>(
method: HttpMethod.Get,
resourceParts: null,
query: query
);
return response.Records;
}
public async Task<IEnumerable<TableInfo>> GetTableNamesAsync(bool includeSchemas, bool refresh = false)
{
SqlQuery query = new SqlQuery { Fields = null };
query.CustomParameters.Add("refresh", refresh);
ResourceWrapper<TableInfo> response = await base.RequestAsync<ResourceWrapper<TableInfo>>(
method: HttpMethod.Get,
resource: "_table",
query: query
);
return response.Records;
}
public async Task<IEnumerable<StorageResource>> GetResourcesAsync(ListingFlags flags)
{
SqlQuery query = new SqlQuery();
query.CustomParameters = AddListingParameters(query.CustomParameters, flags);
ResourceWrapper<StorageResource> response = await base.RequestAsync<ResourceWrapper<StorageResource>>(
method: HttpMethod.Get,
resource: string.Empty,
query: query
);
return response.Records;
}
