/// <summary>
/// Find all Greenhouse's
/// </summary>
/// <param name="dc"></param>
/// <returns>return an IQueryable collection of Greenhouse</returns>
public IQueryable<Domain.Greenhouse> Find(DataContext dc)
{
dc = dc ?? Conn.GetContext();
var r = from g in dc.Greenhouses
let greenhouseUsers = LoadGreenhouseUsers(dc, g.GreenhouseID)
let sections = LoadSections(dc, g.GreenhouseID)
select new Domain.Greenhouse
{
ID = g.GreenhouseID,
GreenhouseUsers = new LazyList<GreenhouseUser>(greenhouseUsers),
Sections = new LazyList<Section>(sections),
Usernames = Usernames,
Address = new Address
{
City = g.City,
StateOrProvince = g.StateOrProvince,
Country = g.Country,
Zip = g.Zip,
StreetLine1 = g.StreetLine1,
StreetLine2 = g.StreetLine2,
IsDefault = g.IsDefault,
}
};
return r;
}
/// <summary>
/// Find all Section's
/// </summary>
/// <param name="dc"></param>
/// <returns>return an IQueryable collection of Section</returns>
public IQueryable<Domain.Section> Find(DataContext dc)
{
dc = dc ?? Conn.GetContext();
var r = from s in dc.Sections
select new Domain.Section
{
ID = s.SectionID,
Name = s.Name,
GreenhouseID = s.GreenhouseID,
PresetID = s.PresetID,
UserID = s.UserID,
Username = s.User.UserName,
IsTemperatureActivated = s.IsTemeratureActivated,
IdealTemperature = s.IdealTemperature,
TemperatureThreshold = s.TemperatureThreshold,
IsLightActivated = s.IsLightActivated,
IdealLightIntensity = s.IdealLightIntensity,
LightIntensityThreshold = s.LightIntensityThreshold,
IsHumidityActivated = s.IsHumidityActivated,
IdealHumidity = s.IdealHumidity,
HumidityThreshold = s.HumidityThreshold,
IsWaterLevelActivated = s.IsWaterLevelActivated,
IdealWaterLevel = s.IdealWaterLevel,
WaterLevelThreshold = s.WaterLevelThreshold,
DateCreated = s.DateCreated,
DateUpdated = s.DateUpdated
};
return r;
}
/// <summary>
/// Save a Product
/// </summary>
/// <param name="dc"></param>
/// <param name="product"></param>
/// <returns>returns the id of the saved product</returns>
public int Save(DataContext dc, Domain.Product product)
{
dc = dc ?? Conn.GetContext();
var dbProduct = dc.Products.Where(p => p.ProductID == product.ID).SingleOrDefault();
var isNew = false;
if (dbProduct == null)
{
dbProduct = new Product();
isNew = true;
}
dbProduct.Name = product.Name;
dbProduct.Description = product.Description;
dbProduct.Price = product.Price;
dbProduct.IsActive = product.IsActive;
dbProduct.Image = product.Image;
dbProduct.DateUpdated = DateTime.Now;
if (isNew)
{
dbProduct.DateCreated = DateTime.Now;
dc.Products.InsertOnSubmit(dbProduct);
}
dc.SubmitChanges();
return dbProduct.ProductID;
}
public IQueryable<Domain.Greenhouse> All(DataContext dc, string username)
{
dc = dc ?? Conn.GetContext();
var r = from g in dc.Greenhouses
join gu in dc.GreenhouseUsers on g.GreenhouseID equals gu.GreenhouseId
let greenhouseUsers = LoadGreenhouseUsers(dc, g.GreenhouseID)
let sections = LoadSections(dc, g.GreenhouseID)
where gu.User.UserName.ToLower() == username.ToLower()
select new Domain.Greenhouse
{
ID = g.GreenhouseID,
GreenhouseUsers = new LazyList<GreenhouseUser>(greenhouseUsers),
Sections = new LazyList<Section>(sections),
Usernames = Usernames,
Address = new Address
{
City = g.City,
StateOrProvince = g.StateOrProvince,
Country = g.Country,
Zip = g.Zip,
StreetLine1 = g.StreetLine1,
StreetLine2 = g.StreetLine2,
IsDefault = g.IsDefault,
}
};
return r;
}
/// <summary>
/// Find all Preset's
/// </summary>
/// <param name="dc">DataContext</param>
/// <returns>return an IQueryable collection of Preset</returns>
public IQueryable<Domain.Preset> All(DataContext dc)
{
dc = dc ?? Conn.GetContext();
var r = from p in dc.Presets
select new Domain.Preset
{
ID = p.PresetID,
Name = p.Name,
UserID = p.UserID,
IdealTemperature = p.IdealTemperature,
TemperatureThreshold = p.TemperatureThreshold,
IdealLightIntensity = p.IdealLightIntensity,
LightIntensityThreshold = p.LightIntensityThreshold,
IdealHumidity = p.IdealHumidity,
HumidityThreshold = p.HumidityThreshold,
IdealWaterLevel = p.IdealWaterLevel,
WaterLevelThreshold = p.WaterLevelThreshold,
IsGlobal = p.IsGlobal,
DateCreated = p.DateCreated,
DateUpdated = p.DateUpdated
};
return r;
}
/// <summary>
/// Save a Preset
/// </summary>
/// <param name="dc">DataContext</param>
/// <param name="preset"></param>
/// <returns>returns the id of the saved preset</returns>
public int Save(DataContext dc, Domain.Preset preset)
{
dc = dc ?? Conn.GetContext();
var dbPreset = dc.Presets.Where(p => p.PresetID == preset.ID).SingleOrDefault();
var isNew = false;
if (dbPreset == null)
{
dbPreset = new Preset();
isNew = true;
}
dbPreset.Name = preset.Name;
dbPreset.UserID = preset.UserID;
dbPreset.IdealTemperature = preset.IdealTemperature;
dbPreset.TemperatureThreshold = preset.TemperatureThreshold;
dbPreset.IdealLightIntensity = preset.IdealLightIntensity;
dbPreset.LightIntensityThreshold = preset.LightIntensityThreshold;
dbPreset.IdealHumidity = preset.IdealHumidity;
dbPreset.HumidityThreshold = preset.HumidityThreshold;
dbPreset.IdealWaterLevel = preset.IdealWaterLevel;
dbPreset.WaterLevelThreshold = preset.WaterLevelThreshold;
dbPreset.IsGlobal = preset.IsGlobal;
dbPreset.DateUpdated = DateTime.Now;
if (isNew)
{
dbPreset.DateCreated = DateTime.Now;
dc.Presets.InsertOnSubmit(dbPreset);
}
dc.SubmitChanges();
return dbPreset.PresetID;
}
/// <summary>
/// Delete a single TaskType
/// </summary>
/// <param name="dc">DataContext</param>
/// <param name="taskType"></param>
public void Delete(DataContext dc, Domain.TaskType taskType)
{
dc = dc ?? Conn.GetContext();
var dbTaskType = dc.TaskTypes.Where(t => t.TaskTypeId == taskType.ID).SingleOrDefault();
if (dbTaskType == null) return;
dc.TaskTypes.Attach(dbTaskType, true);
dc.TaskTypes.DeleteOnSubmit(dbTaskType);
dc.SubmitChanges();
}
/// <summary>
/// Delete a single product
/// </summary>
/// <param name="dc"></param>
/// <param name="product"></param>
public void Delete(DataContext dc, Domain.Product product)
{
dc = dc ?? Conn.GetContext();
var dbProduct = dc.Products.Where(p => p.ProductID == product.ID).SingleOrDefault();
if (dbProduct == null) return;
dc.Products.Attach(dbProduct, true);
dc.Products.DeleteOnSubmit(dbProduct);
dc.SubmitChanges();
}
/// <summary>
/// Delete a single TaskRepository
/// </summary>
/// <param name="dc">DataContext</param>
/// <param name="task"></param>
public void Delete(DataContext dc, Domain.Task task)
{
dc = dc ?? Conn.GetContext();
var dbTask = dc.Tasks.Where(t => t.TaskID == task.ID).SingleOrDefault();
if (dbTask == null) return;
//dc.Tasks.Attach(dbTask, true);
dc.Tasks.DeleteOnSubmit(dbTask);
dc.SubmitChanges();
}
/// <summary>
/// Delete a single greenhouse
/// </summary>
/// <param name="dc"></param>
/// <param name="greenhouse"></param>
public void Delete(DataContext dc, Domain.Greenhouse greenhouse)
{
dc = dc ?? Conn.GetContext();
var dbGreenhouse = dc.Greenhouses.Where(g => g.GreenhouseID == greenhouse.ID).SingleOrDefault();
if (dbGreenhouse == null) return;
dc.GreenhouseUsers.DeleteAllOnSubmit(dbGreenhouse.GreenhouseUsers);
foreach (var section in dbGreenhouse.Sections) { dc.Tasks.DeleteAllOnSubmit(section.Tasks); }
dc.Sections.DeleteAllOnSubmit(dbGreenhouse.Sections);
dc.Greenhouses.DeleteOnSubmit(dbGreenhouse);
dc.SubmitChanges();
}
/// <summary>
/// Delete a single
/// </summary>
/// <param name="dc"></param>
/// <param name="section"></param>
public void Delete(DataContext dc, Domain.Section section)
{
dc = dc ?? Conn.GetContext();
var dbSection = dc.Sections.Where(s => s.SectionID == section.ID).SingleOrDefault();
if (dbSection == null) return;
foreach (var task in dbSection.Tasks)
{
dc.Tasks.DeleteOnSubmit(task);
}
dc.Sections.DeleteOnSubmit(dbSection);
dc.SubmitChanges();
}
/// <summary>
/// Find all TaskType's
/// </summary>
/// <param name="dc">DataContext</param>
/// <returns>return an IQueryable collection of TaskType</returns>
public IQueryable<Domain.TaskType> All(DataContext dc)
{
dc = dc ?? Conn.GetContext();
var r = from t in dc.TaskTypes
select new Domain.TaskType
{
ID = t.TaskTypeId,
Name = t.Name,
Type = (TaskTypes)Enum.Parse(typeof(TaskTypes), t.Name)
};
return r;
}
public IQueryable<Domain.GreenhouseUser> Find(DataContext dc)
{
dc = dc ?? Conn.GetContext();
var r = from gu in dc.GreenhouseUsers
select new Domain.GreenhouseUser
{
ID = gu.GreenhouseUserId,
UserID = gu.UserId,
Username = gu.User.UserName,
GreenhouseID = gu.GreenhouseId
};
return r;
}
/// <summary>
/// Find TaskType by it's Enum type
/// </summary>
/// <param name="dc"></param>
/// <param name="type"></param>
/// <returns></returns>
public Domain.TaskType Find(DataContext dc, TaskTypes type)
{
var result = All(dc).Where(t => t.Name == type.ToString()).SingleOrDefault();
if (result == null)
{
result = new Domain.TaskType
{
Name = type.ToString(),
Type = type
};
result.Save();
}
return result;
}
public void Delete(DataContext dc, Domain.GreenhouseUser greenhouseUser)
{
dc = dc ?? Conn.GetContext();
var dbGreenhouseUser = dc.GreenhouseUsers.Where(g => g.GreenhouseUserId == greenhouseUser.ID).SingleOrDefault();
if (dbGreenhouseUser == null) return;
foreach (var section in dbGreenhouseUser.Greenhouse.Sections.Where(gu => gu.UserID == dbGreenhouseUser.UserId))
{
dc.Sections.DeleteOnSubmit(section);
foreach (var task in section.Tasks)
{
dc.Tasks.DeleteOnSubmit(task);
}
}
dc.GreenhouseUsers.DeleteOnSubmit(dbGreenhouseUser);
dc.SubmitChanges();
}
/// <summary>
/// Find all Product's
/// </summary>
/// <param name="dc"></param>
/// <returns>return an IQueryable collection of Product</returns>
public IList<Domain.Product> All(DataContext dc)
{
dc = dc ?? Conn.GetContext();
var r = from p in dc.Products
select new Domain.Product
{
ID = p.ProductID,
Name = p.Name,
Description = p.Description,
Price = p.Price,
IsActive = p.IsActive,
Image = p.Image,
DateUpdated = p.DateUpdated,
DateCreated = p.DateCreated
};
return r.ToList();
}
/// <summary>
/// Find all TaskRepository's
/// </summary>
/// <param name="dc">DataContext</param>
/// <returns>return an IQueryable collection of TaskRepository</returns>
public IQueryable<Domain.Task> All(DataContext dc)
{
dc = dc ?? Conn.GetContext();
var r = from t in dc.Tasks
select new Domain.Task
{
ID = t.TaskID,
SectionID = t.SectionID,
StartTime = t.StartTime,
EndTime = t.EndTime,
Interval = (t.EndTime.TimeOfDay - t.StartTime.TimeOfDay).TotalMinutes,
TaskTypeId = t.TaskTypeID,
DateCreated = t.DateCreated,
DateUpdated = t.DateUpdated
};
return r;
}
public int Save(DataContext dc, Domain.GreenhouseUser greenhouseUser)
{
dc = dc ?? Conn.GetContext();
var dbGreenhouseUser = dc.GreenhouseUsers.Where(g => g.GreenhouseUserId == greenhouseUser.ID).SingleOrDefault();
var isNew = false;
if (dbGreenhouseUser == null)
{
dbGreenhouseUser = new GreenhouseUser();
isNew = true;
}
dbGreenhouseUser.UserId = greenhouseUser.UserID;
dbGreenhouseUser.GreenhouseId = greenhouseUser.GreenhouseID;
if (isNew)
{
dc.GreenhouseUsers.InsertOnSubmit(dbGreenhouseUser);
}
dc.SubmitChanges();
greenhouseUser.ID = dbGreenhouseUser.GreenhouseId;
return greenhouseUser.ID;
}
/// <summary>
/// Find all Task's
/// </summary>
/// <param name="dc">DataContext</param>
/// <returns>return an IQueryable collection of Task</returns>
public static IQueryable<Task> All(DataContext dc)
{
return Repository.All(dc);
}
/// <summary>
/// Save Task
/// </summary>
/// <param name="dc"></param>
/// <returns>returns the id of the saved task</returns>
public int Save(DataContext dc)
{
return Save(dc, this);
}
/// <summary>
/// Delete Task
/// </summary>
/// <param name="dc"></param>
public void Delete(DataContext dc)
{
Delete(dc, this);
}
/// <summary>
/// Save a Task
/// </summary>
/// <param name="dc">DataContext</param>
/// <param name="task"></param>
/// <returns>returns the id of the saved task</returns>
public static int Save(DataContext dc, Task task)
{
return Repository.Save(dc, task);
}
/// <summary>
/// Find an Task by it's id.
/// </summary>
/// <param name="dc"></param>
/// <param name="id"></param>
/// <returns>returns a Task</returns>
public static Task Find(DataContext dc, int id)
{
return Repository.Find(dc, id);
}
public DataContext GetContext()
{
// maybe make more data connections
var dc = new DataContext();
return dc;
}
public static IQueryable<Greenhouse> FindByUsername(DataContext dc, string username)
{
if (username == null) Find(dc);
return Repository.Find(dc, username);
}
/// <summary>
/// Find all Greenhouse's
/// </summary>
/// <param name="dc"></param>
/// <returns>return an IQueryable collection of Greenhouse</returns>
public static IQueryable<Greenhouse> Find(DataContext dc)
{
return Repository.Find(dc);
}
/// <summary>
/// Delete a single greenhouse
/// </summary>
/// <param name="dc"></param>
/// <param name="greenhouse"></param>
public static void Delete(DataContext dc, Greenhouse greenhouse)
{
Repository.Delete(dc, greenhouse);
}
/// <summary>
/// Save a Greenhouse
/// </summary>
/// <param name="dc"></param>
/// <param name="greenhouse"></param>
/// <returns>returns the id of the saved greenhouse</returns>
public static int Save(DataContext dc, Greenhouse greenhouse)
{
return Repository.Save(dc, greenhouse);
}
/// <summary>
/// Find an Product by it's id.
/// </summary>
/// <param name="dc"></param>
/// <param name="id"></param>
/// <returns>returns a Product</returns>
public Domain.Product Find(DataContext dc, int id)
{
return All(dc).Where(p => p.ID == id).SingleOrDefault();
}
/// <summary>
/// Delete a single Task
/// </summary>
/// <param name="dc">DataContext</param>
/// <param name="task"></param>
public static void Delete(DataContext dc, Task task)
{
Repository.Delete(dc, task);
}
