/// <summary>
/// Create a new home
/// </summary>
/// <param name="home">The home to create</param>
/// <param name="user">The user creating the home</param>
/// <returns></returns>
async Task <Home> IHomeLayer.CreateHome(Home home, Guid user)
{
return(await this.connectionManager.ExecuteSql(
"hub.createhome",
collection =>
{
collection.AddWithValue("name", home.Name);
collection.AddWithValue("user", user);
},
reader =>
{
reader.Read();
return SqlDataLayer.ReadHome(reader);
},
this.tokenSource.Token));
}
/// <summary>
/// Get the homes for a user
/// </summary>
/// <param name="user">The user id</param>
/// <returns>A list of all homes for this user</returns>
async Task <IEnumerable <Home> > IHomeLayer.GetHomes(Guid user)
{
return(await this.connectionManager.ExecuteSql(
"hub.gethomes",
collection =>
{
collection.AddWithValue("user", user);
},
reader =>
{
var result = new List <Home>();
while (reader.Read())
{
result.Add(SqlDataLayer.ReadHome(reader));
}
return result;
},
this.tokenSource.Token));
}
/// <summary>
/// Get all devices for a home
/// </summary>
/// <param name="user">The user to get for</param>
/// <param name="home">The home</param>
/// <returns>The list of all devices attached to a home</returns>
async Task <IEnumerable <Device> > IDeviceLayer.GetAllDevices(Guid user, Guid home)
{
return(await this.connectionManager.ExecuteSql(
"hub.getdevices",
parameters =>
{
parameters.AddWithValue("home", home);
parameters.AddWithValue("user", user);
},
reader =>
{
var functions = SqlDataLayer.GetDeviceFunctions(reader);
reader.NextResult();
var devices = new List <Device>();
while (reader.Read())
{
var deviceDefinitionGuid = (Guid)reader["devicedefinition"];
var definition = new DeviceDefinition(
deviceDefinitionGuid,
(string)reader["manufacturer"],
(string)reader["product"],
(DeviceType)reader["type"],
functions[deviceDefinitionGuid]);
var device = new Device(
(Guid)reader["id"],
home,
(string)reader["name"],
(string)reader["description"],
definition,
(string)reader["meta"]);
devices.Add(device);
}
return devices;
},
this.tokenSource.Token));
}
/// <summary>
/// Get the device definitions
/// </summary>
/// <returns>The dictionary of device definitions</returns>
async Task <Dictionary <string, IEnumerable <DeviceDefinition> > > IDeviceDefinitions.GetDefinitions()
{
var devices = await this.connectionManager.ExecuteSql(
"hub.getdefinitions",
collection => { },
reader =>
{
var func = SqlDataLayer.GetDeviceFunctions(reader);
reader.NextResult();
var definitions = new Dictionary <string, IEnumerable <DeviceDefinition> >();
while (reader.Read())
{
var id = (Guid)reader["id"];
var manufacturer = (string)reader["name"];
var definition = new DeviceDefinition(
id,
manufacturer,
(string)reader["product"],
(DeviceType)reader["type"],
func[id]);
if (false == definitions.ContainsKey(manufacturer))
{
definitions.Add(manufacturer, new List <DeviceDefinition>());
}
((List <DeviceDefinition>)definitions[manufacturer]).Add(definition);
}
return(definitions);
},
this.tokenSource.Token);
return(devices);
}
/// <summary>
/// Create a new device
/// </summary>
/// <param name="name">The name</param>
/// <param name="home">The home</param>
/// <param name="description">The description</param>
/// <param name="definition">The definition</param>
/// <param name="meta">The metadata about the device</param>
/// <returns>The new device</returns>
async Task <Device> IDeviceLayer.CreateDevice(string name, Guid home, string description, Guid definition, string meta)
{
return(await this.connectionManager.ExecuteSql(
"hub.adddevice",
collection =>
{
collection.AddWithValue("name", name);
collection.AddWithValue("home", home);
collection.AddWithValue("description", description);
collection.AddWithValue("definition", definition);
collection.AddWithValue("meta", meta);
},
reader =>
{
// Get the guid for the new device
reader.Read();
var id = (Guid)reader["id"];
reader.NextResult();
// Read the functions
var functions = SqlDataLayer.GetDeviceFunctions(reader);
reader.NextResult();
// read the device definition
reader.Read();
var defintion = new DeviceDefinition(
definition,
(string)reader["manufacturer"],
(string)reader["product"],
(DeviceType)reader["type"],
functions[definition]);
return new Device(id, home, name, description, defintion, meta);
},
this.tokenSource.Token));
}
