public PartialViewResult EditAppThingTypePV(int appThingTypeID)
{
AppThingCategory model = uof_repos.repoAppThingCategorys.Find(appThingTypeID);
ViewBag.IconGUID = new SelectList(uof_repos.repoMediaFiles.GetList(), "GUID", "Title", uof_repos.repoMediaFiles.GetList()[0].GUID);
return(PartialView("_App_ThingTypes_Edit", model));
}
public PartialViewResult AddAppThingTypePV(int appID)
{
AppThingCategory model = new AppThingCategory();
ViewBag.IconGUID = new SelectList(uof_repos.repoMediaFiles.GetList(), "GUID", "Title", uof_repos.repoMediaFiles.GetList()[0].GUID);
model.AppID = appID;
return(PartialView("_App_ThingTypes_Add", model));
}
public ActionResult DeleteAppThingTypePV(AppThingCategory model)
{
ResultInfo.Result res = ResultInfo.GetResultByID(1);
if (ModelState.IsValid)
{
res = uof_repos.repoAppThingCategorys.Delete(model.ID, currentUser.Id);
return(Json(res));
}
return(Json(res));
}
public ActionResult AddAppThingTypePV(AppThingCategory model)
{
ResultInfo.Result res = ResultInfo.GetResultByID(1);
if (ModelState.IsValid)
{
res = uof_repos.repoAppThingCategorys.Add(model.Title, model.Code, Guid.NewGuid(), model.IconGUID, model.AppID, currentUser.Id);
return(Json(res));
}
return(Json(res));
}
public ResultInfo.Result Delete(long id, string userID)
{
try
{
AppThingCategory appThingCategory = db.AppThingCategorys.Find(id);
db.AppThingCategorys.Remove(appThingCategory);
db.SaveChanges();
return(ResultInfo.GenerateOKResult("Deleted", appThingCategory.ID));
}
catch
{
return(ResultInfo.GetResultByID(1));
}
}
public ResultInfo.Result Edit(long id, string title, Guid iconGuid, string userID)
{
try
{
AppThingCategory appThingCategory = db.AppThingCategorys.Find(id);
appThingCategory.Title = title;
appThingCategory.IconGUID = iconGuid;
db.SaveChanges();
return(ResultInfo.GenerateOKResult("Saved", appThingCategory.ID));
}
catch
{
return(ResultInfo.GetResultByID(1));
}
}
public AppThingCategory Find(long id)
{
AppThingCategory appThingCategory = new AppThingCategory();
List <AppThingCategory> appThingCategorys = db.AppThingCategorys
//.Include("AppAPIEntitys").Include("AppStatuss")
.Where(l => l.ID == id).ToList();
if (appThingCategorys.Count == 1)
{
appThingCategory = appThingCategorys[0];
}
else
{
throw new Exception("Not Found");
}
return(appThingCategory);
}
public ResultInfo.Result Add(string title, string code, Guid guid, Guid iconGuid, long appID, string userID)
{
AppThingCategory appThingCategory = new AppThingCategory();
//Save new app in database
try
{
appThingCategory.AppID = appID;
appThingCategory.Title = title;
appThingCategory.Code = code;
appThingCategory.GUID = guid;
appThingCategory.IconGUID = iconGuid;
db.AppThingCategorys.Add(appThingCategory);
db.SaveChanges();
return(ResultInfo.GenerateOKResult("Saved", appThingCategory.ID));
}
catch (Exception ex)
{
return(ResultInfo.GenerateErrorResult("Error", ex.Message));
}
}
public async Task <App> InstallOrUpdateStoreApp(Guid guid)
{
APIAppResponseModels.GetAppByGUID model = await GetAppByGUIDAsync(guid);
//Verify Install or Update
List <App> appsList = db.Apps.Where(a => a.GUID == guid).ToList();
if (appsList.Count == 0)
{//New App
#region Install New App from Store
#region Add App
////App
App app = new App();
app.GUID = model.App.GUID;
app.Key = Guid.NewGuid();
app.Title = model.App.Title;
app.Description = model.App.Description;
app.CreatedByID = model.App.DevelopedBy.Id;
app.CreateDate = model.App.CreateDate;
app.StatusID = model.App.Status.Id;
app.IsStoreApp = true;
app.DevelopedById = model.App.DevelopedBy.Id;
app.DevelopedByName = model.App.DevelopedBy.FullName;
app.DevelopedByCompany = model.App.DevelopedBy.Company;
app.StoreAppLastUpdate = DateTime.Now;
app.Version = model.App.LatestVersion;
db.Apps.Add(app);
db.SaveChanges();
#endregion
#region Add APIEntities
foreach (APISystemEntity api in model.App.AllowedEntities)
{
AppAPIEntity appAPI = new AppAPIEntity();
appAPI.AppID = app.ID;
appAPI.SystemEntityID = api.ID;
db.AppAPIEntitys.Add(appAPI);
db.SaveChanges();
}
#endregion
#region Add MediaFiles
foreach (APIAppMediaFile apiAppMediaFile in model.App.AppMediaFiles)
{
AppMediaFile appMediaFile = new AppMediaFile();
appMediaFile.GUID = apiAppMediaFile.GUID;
appMediaFile.Title = apiAppMediaFile.Title;
appMediaFile.AppID = app.ID;
db.AppMediaFiles.Add(appMediaFile);
db.SaveChanges();
}
#endregion
#region Add EndpointTypes
////App EndpointTypes
foreach (APIAppEndpointType apiAppEndType in model.App.AppEndpointTypes)
{
AppEndpointType appEndpointType = new AppEndpointType();
appEndpointType.Code = apiAppEndType.Code;
appEndpointType.GUID = apiAppEndType.GUID;
appEndpointType.AppID = app.ID;
appEndpointType.Title = apiAppEndType.Title;
appEndpointType.Measurement = apiAppEndType.Measurement;
appEndpointType.TypeCategoryID = apiAppEndType.TypeCategoryID;
appEndpointType.IconGUID = apiAppEndType.IconGuid;
db.AppEndpointTypes.Add(appEndpointType);
db.SaveChanges();
}
#endregion
#region Add ThingTypes
////App ThingTypes
foreach (APIAppThingType apiAppThingType in model.App.AppThingTypes)
{
AppThingCategory appThingType = new AppThingCategory();
appThingType.Code = apiAppThingType.Code;
appThingType.GUID = apiAppThingType.GUID;
appThingType.AppID = app.ID;
appThingType.Title = apiAppThingType.Title;
appThingType.IconGUID = apiAppThingType.IconGuid;
db.AppThingCategorys.Add(appThingType);
db.SaveChanges();
}
#endregion
#region Add ThingTypeExtension
////App ThingTypes
foreach (APIAppThingExtension apiAppThingExtension in model.App.AppThingExtensions)
{
AppThingExtension appThingExtension = new AppThingExtension();
appThingExtension.Code = apiAppThingExtension.Code;
appThingExtension.GUID = apiAppThingExtension.GUID;
appThingExtension.AppID = app.ID;
appThingExtension.Title = apiAppThingExtension.Title;
appThingExtension.AppThingCategoryCode = apiAppThingExtension.ThingTypeCode;
appThingExtension.DataTypeID = (int)apiAppThingExtension.DataType.ID;
appThingExtension.IsList = apiAppThingExtension.IsList;
db.AppThingExtensions.Add(appThingExtension);
db.SaveChanges();
}
#endregion
#endregion
}
else
{// Update App
#region Update Existing App from Store
#region Update App
App app = appsList[0];
app.GUID = model.App.GUID;
app.Key = Guid.NewGuid();
app.Title = model.App.Title;
app.Description = model.App.Description;
app.CreatedByID = model.App.DevelopedBy.Id;
app.CreateDate = model.App.CreateDate;
app.StatusID = model.App.Status.Id;
app.IsStoreApp = true;
app.DevelopedById = model.App.DevelopedBy.Id;
app.DevelopedByName = model.App.DevelopedBy.FullName;
app.DevelopedByCompany = model.App.DevelopedBy.Company;
app.StoreAppLastUpdate = DateTime.Now;
app.Version = model.App.LatestVersion;
db.SaveChanges();
#endregion
#region Add Missing APIEntities
//Filter Only the missing App API Entities
var toBeAddedAppAPIEntities_Query =
from storeAppEntities in model.App.AllowedEntities
where !(from localAppEntities in app.AppAPIEntitys
select localAppEntities.SystemEntityID)
.Contains(storeAppEntities.ID)
select storeAppEntities;
//Add the Filtered AppAPIEntities to Local App
foreach (APISystemEntity api in toBeAddedAppAPIEntities_Query)
{
AppAPIEntity appAPI = new AppAPIEntity();
appAPI.AppID = app.ID;
appAPI.SystemEntityID = api.ID;
db.AppAPIEntitys.Add(appAPI);
db.SaveChanges();
}
#endregion
#region Delete Extra APIEntities
//Filter Only the Extra App API Entities
var toBeDeletedAppAPIEntities_Query =
from localAppEntities in app.AppAPIEntitys
where !(from storeAppEntities in model.App.AllowedEntities
select storeAppEntities.ID)
.Contains(localAppEntities.SystemEntityID)
select localAppEntities;
//Add the Filtered AppAPIEntities to Local App
foreach (AppAPIEntity api in toBeDeletedAppAPIEntities_Query)
{
db.AppAPIEntitys.Remove(api);
//db.AppAPIEntitys.Where(a => a.AppID == api.AppID && a.SystemEntityID == api.SystemEntityID).ToList()[0];
db.SaveChanges();
}
#endregion
#region Add Missing & Update MediaFiles
List <AppMediaFile> localAppMediaFiles = db.AppMediaFiles.Where(et => et.App.GUID == app.GUID).ToList();
foreach (APIAppMediaFile apiAppMediaFile in model.App.AppMediaFiles)
{
if (localAppMediaFiles.Any(l => l.GUID == apiAppMediaFile.GUID))
{//Exist
AppMediaFile toBeUpdatedAppMediaFile = localAppMediaFiles.First(l => l.GUID == apiAppMediaFile.GUID);
toBeUpdatedAppMediaFile.Title = apiAppMediaFile.Title;
db.SaveChanges();
}
else
{//Not Exist
AppMediaFile toBeAddedAppMediaFile = new AppMediaFile();
toBeAddedAppMediaFile.GUID = apiAppMediaFile.GUID;
toBeAddedAppMediaFile.AppID = app.ID;
toBeAddedAppMediaFile.Title = apiAppMediaFile.Title;
db.AppMediaFiles.Add(toBeAddedAppMediaFile);
db.SaveChanges();
}
}
#endregion
#region Add Missing & Update EndpointTypes
List <AppEndpointType> localAppEndpointTypes = db.AppEndpointTypes.Where(et => et.App.GUID == app.GUID).ToList();
foreach (APIAppEndpointType apiAppEndpointType in model.App.AppEndpointTypes)
{
if (localAppEndpointTypes.Any(l => l.GUID == apiAppEndpointType.GUID))
{//Exist
AppEndpointType toBeUpdatedAppEndpointType = localAppEndpointTypes.First(l => l.GUID == apiAppEndpointType.GUID);
toBeUpdatedAppEndpointType.Title = apiAppEndpointType.Title;
toBeUpdatedAppEndpointType.Measurement = apiAppEndpointType.Measurement;
toBeUpdatedAppEndpointType.TypeCategoryID = apiAppEndpointType.TypeCategoryID;
toBeUpdatedAppEndpointType.Code = apiAppEndpointType.Code;
toBeUpdatedAppEndpointType.IconGUID = apiAppEndpointType.IconGuid;
db.SaveChanges();
}
else
{//Not Exist
AppEndpointType toBeAddedAppEndpointType = new AppEndpointType();
toBeAddedAppEndpointType.GUID = apiAppEndpointType.GUID;
toBeAddedAppEndpointType.AppID = app.ID;
toBeAddedAppEndpointType.Title = apiAppEndpointType.Title;
toBeAddedAppEndpointType.Measurement = apiAppEndpointType.Measurement;
toBeAddedAppEndpointType.TypeCategoryID = apiAppEndpointType.TypeCategoryID;
toBeAddedAppEndpointType.Code = apiAppEndpointType.Code;
toBeAddedAppEndpointType.IconGUID = apiAppEndpointType.IconGuid;
db.AppEndpointTypes.Add(toBeAddedAppEndpointType);
db.SaveChanges();
}
}
#endregion
#region Add Missing & Update ThingTypes
List <AppThingCategory> localAppThingTypes = db.AppThingCategorys.Where(et => et.App.GUID == app.GUID).ToList();
foreach (APIAppThingType apiAppThingType in model.App.AppThingTypes)
{
if (localAppThingTypes.Any(l => l.GUID == apiAppThingType.GUID))
{//Exist
AppThingCategory toBeUpdatedAppThingType = localAppThingTypes.First(l => l.GUID == apiAppThingType.GUID);
toBeUpdatedAppThingType.Title = apiAppThingType.Title;
toBeUpdatedAppThingType.Code = apiAppThingType.Code;
toBeUpdatedAppThingType.IconGUID = apiAppThingType.IconGuid;
db.SaveChanges();
}
else
{//Not Exist
AppThingCategory toBeAddedAppThingType = new AppThingCategory();
toBeAddedAppThingType.GUID = apiAppThingType.GUID;
toBeAddedAppThingType.AppID = app.ID;
toBeAddedAppThingType.Title = apiAppThingType.Title;
toBeAddedAppThingType.Code = apiAppThingType.Code;
toBeAddedAppThingType.IconGUID = apiAppThingType.IconGuid;
db.AppThingCategorys.Add(toBeAddedAppThingType);
db.SaveChanges();
}
}
#endregion
#region Add Missing & Update ThingExtensions
List <AppThingExtension> localAppThingExtensions = db.AppThingExtensions.Where(et => et.App.GUID == app.GUID).ToList();
foreach (APIAppThingExtension apiAppThingExtension in model.App.AppThingExtensions)
{
if (localAppThingExtensions.Any(l => l.GUID == apiAppThingExtension.GUID))
{//Exist
AppThingExtension toBeUpdatedAppThingExtension = localAppThingExtensions.First(l => l.GUID == apiAppThingExtension.GUID);
toBeUpdatedAppThingExtension.Title = apiAppThingExtension.Title;
toBeUpdatedAppThingExtension.Code = apiAppThingExtension.Code;
toBeUpdatedAppThingExtension.AppThingCategoryCode = apiAppThingExtension.ThingTypeCode;
toBeUpdatedAppThingExtension.DataTypeID = (int)apiAppThingExtension.DataType.ID;
toBeUpdatedAppThingExtension.IsList = apiAppThingExtension.IsList;
db.SaveChanges();
}
else
{//Not Exist
AppThingExtension toBeAddedAppThingExtension = new AppThingExtension();
toBeAddedAppThingExtension.GUID = apiAppThingExtension.GUID;
toBeAddedAppThingExtension.AppID = app.ID;
toBeAddedAppThingExtension.Title = apiAppThingExtension.Title;
toBeAddedAppThingExtension.Code = apiAppThingExtension.Code;
toBeAddedAppThingExtension.AppThingCategoryCode = apiAppThingExtension.ThingTypeCode;
toBeAddedAppThingExtension.DataTypeID = (int)apiAppThingExtension.DataType.ID;
toBeAddedAppThingExtension.IsList = apiAppThingExtension.IsList;
db.AppThingExtensions.Add(toBeAddedAppThingExtension);
db.SaveChanges();
}
}
#endregion
#endregion
}
return(db.Apps.Where(a => a.GUID == model.App.GUID).ToList()[0]);
}
public PartialViewResult DeleteAppThingTypePV(int appThingTypeID)
{
AppThingCategory model = uof_repos.repoAppThingCategorys.Find(appThingTypeID);
return(PartialView("_App_ThingTypes_Delete", model));
}
