public static async Task <AppFileValue> SaveImage(this TDContext db, string ImageData, string Path, string id = null)
{
AppFile find = null;
if (id != null && id.Length > 0)
{
find = await db.AppFiles.FindAsync(id);
}
if (find == null)
{
var saveFile = ImageData.WriteImageString(Path);
if (!saveFile.Success)
{
return(AppFileValue.Error(saveFile.Message));
}
find = new AppFile(new DBHelper().GetAppFileId(db), saveFile.FileName);
find.UploadType = UploadType.Image;
find.FullPath = saveFile.Output.Replace(HttpContext.Current.Server.MapPath("~"), "").Replace("\\", "/");
db.AppFiles.Add(find);
}
else
{
var filepath = HttpContext.Current.Server.MapPath("~" + find.FullPath);
var saveFile = ImageData.WriteImageString(null, filepath);
if (!saveFile.Success)
{
return(AppFileValue.Error(saveFile.Message));
}
find.FileName = saveFile.FileName;
find.UploadType = UploadType.Image;
find.FullPath = saveFile.Output.Replace(HttpContext.Current.Server.MapPath("~"), "").Replace("\\", "/");
db.Entry(find).State = EntityState.Modified;
}
return(AppFileValue.Success(find));
}
public ServerConfig GetServer(string UserName, string Password, string AppId, string PartnerId)
{
var deuserName = UserName;
var dePassword = Password.ToDecrypt();
var user = UserManager.FindByName(deuserName);
if (user == null || user.PasswordHash.ToDecrypt() != dePassword)
{
return(null);
}
var db = new TDContext();
var partnerApp = db.ClientApps.Find(PartnerId, AppId);
if (partnerApp == null)
{
return(null);
}
return(new ServerConfig
{
UserName = UserName,
Password = user.PasswordHash,
AppId = AppId,
PartnerId = PartnerId,
LocalAddress = partnerApp.LocalIP,
Port = partnerApp.Port,
PartnerName = partnerApp.Client.Name
});
}
public RM.Data.UserView UpdateServerIp(ServerConfig config)
{
var user = UserManager.FindByName(config.UserName);
if (user == null || user.PasswordHash.ToDecrypt() != config.Password.ToDecrypt())
{
return(null);
}
var db = new TDContext();
var userPartnerApp = db.UserApps.SingleOrDefault(x => x.UserId == user.Id && x.ClientId == config.PartnerId && x.AppId == config.AppId);
if (userPartnerApp == null)
{
return(null);
}
var partnerApp = db.ClientApps.Find(config.PartnerId, config.AppId);
partnerApp.LocalIP = config.LocalAddress;
partnerApp.Port = config.Port;
partnerApp.PublicIP = GetClientIp(Request);
db.Entry(partnerApp).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(new RM.Data.UserView
{
Id = user.Id.ToGuid(),
UserName = user.UserName,
Password = user.PasswordHash,
GroupType = RM.GroupType.Boss
});
}
public async Task <ActionResult> VerifyPhoneNumber(string PhoneNumber, string Code)
{
if (!ModelState.IsValid)
{
return(Json(Js.Error(Global.PleaseCheckYourCode)));;
}
string phoneNumber = UserManager.GetPhoneNumber(User.Identity.GetUserId());
var code = await UserManager.GenerateChangePhoneNumberTokenAsync(User.Identity.GetUserId(), PhoneNumber);
if (code == Code)
{
using (var db = new TDContext())
{
var dbUser = db.Users.Find(User.Identity.GetUserId());
dbUser.PhoneNumber = PhoneNumber;
dbUser.PhoneNumberConfirmed = true;
db.SaveChanges();
}
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
}
return(Json(Js.SuccessLoad(Global.YourPhoneNumberHasBeenSet)));;
}
return(Json(Js.Error(Global.GenericError)));;
}
public async Task <DBAction> Create(AppEditModel dataModel, string userId)
{
using (var db = new TDContext())
{
dataModel.Id = new DBHelper().GetAppId(db);
var app = new App(dataModel);
app.ModiyId = userId;
app.LastModify = DateTime.UtcNow;
var gallery = new GalleryDB(db).Create(app);
if (!string.IsNullOrEmpty(dataModel.ImageData))
{
var save = await db.SaveImage(dataModel.ImageData, "apps", null);
if (!save.OK)
{
return(new DBAction(save.Message, false));
}
gallery.AppFiles.Add(save.Image);
}
db.Apps.Add(app);
var str = await db.SaveMessageAsync();
if (!string.IsNullOrEmpty(str))
{
return(new DBAction(str, false));
}
return(new DBAction(app.Id));
}
}
public async Task <ActionResult> DeleteConfirmed(string id)
{
using (var db = new TDContext())
{
User data = db.Users.Find(id);
if (data != null)
{
if (data.AvatarId != null)
{
var image = data.Avatar;
db.AppFiles.Remove(image);
string filePath = Server.MapPath("~/data/img/users/" + id);// + string.Format(Properties.Resources.UserImageLink, id));
filePath.DeleteFile();
}
db.Users.Remove(data);
var str = await db.SaveMessageAsync();
if (str != null)
{
return(Json(str.GetError()));
}
return(Json(Js.SuccessRedirect(Global.UserRemoved, "/admin/users")));
}
return(Json(Js.Error()));
}
}
public async Task <ActionResult> AppVersionsAdd(AppVersionView model)
{
using (var db = new TDContext())
{
if (!ModelState.IsValid)
{
return(Json(Js.Error(this.GetModelStateError())));
}
var version = model.Selected.ToEnum <LicenseType>();
var data = await db.AppVersions.FindAsync(model.AppId, version);
if (data != null)
{
return(Json("Đã tồn tại phiên bản ứng dụng này".GetError()));
}
model.Version = version;
data = new AppVersion(model);
db.AppVersions.Add(data);
var str = await db.SaveDatabase();
if (str != null)
{
return(Json(str.GetError()));
}
return(Json(Js.SuccessRedirect("Đã thêm phiên bản", TD.Properties.Resources.AdminAppsLink + "/AppVersionsEdit?AppId=" + model.AppId + "&Version=" + version)));
}
}
public async Task <ActionResult> AppVersionsDelete(string AppId, LicenseType?Version)
{
using (var db = new TDContext())
{
if (string.IsNullOrEmpty(AppId) || Version == null)
{
return(Json(TD.Global.AppVersionNotFound.GetError()));
}
var data = await db.AppVersions.FindAsync(AppId, Version.Value);
if (data == null)
{
return(Json(TD.Global.AppVersionNotFound.GetError()));
}
db.AppVersions.Remove(data);
var str = await db.SaveDatabase();
if (str != null)
{
return(Json(str.GetError()));
}
return(Json(Js.SuccessRedirect(TD.Global.AppVersionRemoved, TD.Properties.Resources.AdminAppEditLink + AppId)));
}
}
public static void Seed(TDContext db)
{
if (!db.Roles.Any(r => r.Name == "SysAdmin"))
{
var storeRole = new RoleStore <IdentityRole>(db);
var managerRole = new RoleManager <IdentityRole>(storeRole);
var role = new IdentityRole {
Name = "SysAdmin"
};
managerRole.Create(role);
}
var store = new UserStore <User>(db);
var manager = new UserManager(store);
var sadmin = db.Users.FirstOrDefault(x => x.UserName == "sadmin");
if (sadmin == null)
{
var user = new User("sadmin");// { UserName = "******" };
manager.Create(user, "pleasechange!");
manager.AddToRole(user.Id, "SysAdmin");
sadmin = db.Users.SingleOrDefault(x => x.UserName == "sadmin");
db.SaveChanges();
}
var test = db.Users.FirstOrDefault(x => x.UserName == "test");
if (test == null)
{
test = new User("test");// { UserName = "******" };
manager.Create(test, "test!!");
test = db.Users.FirstOrDefault(x => x.UserName == "test");
}
}
public async Task <ActionResult> FeatureAppsEdit(FeatureAppView model)
{
using (var db = new TDContext())
{
if (!ModelState.IsValid)
{
return(Json(Js.Error(this.GetModelStateError())));
}
var data = await db.FeatureApps.FindAsync(model.Id);
if (data == null)
{
return(Json(string.Format("Không tìm thấy chức năng : {0} Mã :{1}", model.Name, model.Id).GetError()));
}
data.Name = model.Name;
db.Entry(data).State = EntityState.Modified;
var result = await db.SaveDatabase();
if (result.NotNull())
{
result.GetError();
}
return(Json(Js.SuccessRedirect("Đã cập nhật chức năng", "/admin/apps/FeatureApps")));
}
}
public async Task <ActionResult> FeatureAppsAdd(FeatureAppView model)
{
using (var db = new TDContext())
{
if (!ModelState.IsValid)
{
return(Json(Js.Error(this.GetModelStateError())));
}
if (await db.FeatureApps.AnyAsync(x => x.Name == model.Name))
{
return(Json(TD.Global.FeatureAppExits.GetError()));
}
var data = new FeatureApp()
{
Name = model.Name
};
db.FeatureApps.Add(data);
var str = await db.SaveDatabase();
if (str != null)
{
return(Json(str.GetError()));
}
return(Json(Js.SuccessRedirect("Đã thêm chức năng", "/admin/apps/AppFeaturesAdd")));;
}
}
public async Task <ActionResult> Edit(UserViewModel model)
{
var db = new TDContext();
var currentUser = User.Identity.GetUserId();
var data = db.Users.Find(model.Id);
if (data == null)
{
return(Json(Js.Error("Không tìm thấy người dùng")));
}
var lstSelect = await GetSelectRole(model.RoleId, db);
var current = data.Roles.ToList();
foreach (var item in current)
{
if (!lstSelect.Contains(item.RoleId))
{
data.Roles.Remove(item);// UserManager.RemoveFromRoleAsync(data.Id, item);
}
}
data.UserName = model.UserName;
data.Email = model.Email;
data.CantSay = model.CantSay;
data.Sign = model.Sign;
data.PasswordHash = model.Password.ToEncrypt();
db.Entry(data).State = EntityState.Modified;
foreach (var item in lstSelect)
{
if (!data.Roles.Any(x => x.RoleId == item))
{
data.Roles.Add(new IdentityUserRole
{
UserId = data.Id,
RoleId = item
});
}
}
db.Entry(data).State = EntityState.Modified;
var str = await db.SaveMessageAsync();
if (str != null)
{
return(Json(str.GetError()));
}
return(Json(Js.SuccessRedirect(Global.UserChanged, "/admin/users")));
}
public async Task <ActionResult> VersionFeatureAppsEdit(VersionFeatureEditModel model)
{
using (var db = new TDContext())
{
if (!ModelState.IsValid)
{
return(Json(Js.Error(this.GetModelStateError())));
}
var FeatureAppId = model.Selected;
var find = db.FeatureApps.Find(FeatureAppId);
if (find == null)
{
find = db.FeatureApps.FirstOrDefault(x => x.Name == model.Selected);
if (find == null)
{
find = new FeatureApp
{
Name = model.Selected
};
db.FeatureApps.Add(find);
var str = await db.SaveDatabase();
if (str != null)
{
return(Json(str.GetError()));
}
}
FeatureAppId = find.Id;
}
model.FeatureAppId = FeatureAppId;
var data = await db.VersionFeatureApps.FindAsync(model.AppId, model.Version, FeatureAppId);
if (data == null)
{
data = new VersionFeature(model);
db.VersionFeatureApps.Add(data);
var str = await db.SaveDatabase();
if (str != null)
{
return(Json(str.GetError()));
}
}
data.Content = model.Content;
db.Entry(data).State = EntityState.Modified;
var result = await db.SaveDatabase();
if (result.NotNull())
{
result.GetError();
}
return(Json(Js.SuccessRedirect(TD.Global.VersionFeatureAppChanged, string.Format("{0}/VersionsEdit?AppId={1}&Version={2}", TD.Properties.Resources.AdminAppEditLink, model.AppId, model.Version))));
}
}
internal static void MakeTempListForMoldRisk()
{
List <Temperature> temperatureList = new List <Temperature>();
using (var db = new TDContext())
{
temperatureList = db.Temperatures.ToList();
}
AddMoldData(temperatureList);
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (db != null)
{
db.Dispose();
db = null;
}
}
base.Dispose(disposing);
}
public async Task <ActionResult> AppFeaturesAdd(AppFeatureView model)
{
using (var db = new TDContext())
{
if (!ModelState.IsValid)
{
return(Json(Js.Error(this.GetModelStateError())));
}
var FeatureAppId = model.Selected;
var find = db.FeatureApps.Find(FeatureAppId);
if (find == null)
{
find = db.FeatureApps.FirstOrDefault(x => x.Name == model.Selected);
if (find == null)
{
find = new FeatureApp
{
Name = model.Selected
};
db.FeatureApps.Add(find);
var str = await db.SaveDatabase();
if (str != null)
{
return(Json(str.GetError()));
}
}
FeatureAppId = find.Id;
}
var data = await db.AppFeatures.FindAsync(model.AppId, FeatureAppId);
if (data != null)
{
return(Json(Global.FeatureAppAppExist.GetError()));
}
data = new AppFeature(model.AppId, FeatureAppId);
data.Content = model.Content;
data.Order = model.Order;
db.AppFeatures.Add(data);
var str2 = await db.SaveDatabase();
if (str2.NotNull())
{
return(Json(str2.GetError()));
}
return(Json(Js.SuccessRedirect(Global.FeatureAppAppAdded, "AppFeaturesAdd/" + model.AppId)));
}
}
public async Task <DBAction> Edit(AppEditModel dataModel, string userId)
{
using (var db = new TDContext())
{
var app = await db.Apps.FindAsync(dataModel.Id);
if (app == null)
{
return(new DBAction(LanguageDB.NotFound, false));
}
app.Name = dataModel.Name;
app.Link = dataModel.Link;
app.Content = dataModel.Content;
app.Database = dataModel.Database;
app.ModiyId = userId;
app.LastModify = DateTime.UtcNow;
if (!string.IsNullOrEmpty(dataModel.ImageData))
{
var gallery = app.Galleries.FirstOrDefault();
if (gallery == null)
{
gallery = new GalleryDB(db).Create(app);
}
var image = gallery.AppFiles.FirstOrDefault();
AppFileValue save;
if (image != null)
{
save = await db.SaveImage(dataModel.ImageData, "apps", image.Id);
}
else
{
save = await db.SaveImage(dataModel.ImageData, "apps", null);
}
if (!save.OK)
{
return(new DBAction(save.Message, false));
}
image = save.Image;
}
db.Entry(app).State = EntityState.Modified;
var str = await db.SaveMessageAsync();
if (!string.IsNullOrEmpty(str))
{
return(new DBAction(str, false));
}
return(new DBAction(app.Id));
}
}
public async Task <ActionResult> Create(UserViewModel model)
{
if (!ModelState.IsValid)
{
return(Json(this.GetModelStateError().GetError()));
}
var db = new TDContext();
var currentUser = User.Identity.GetUserId();
var lstSelect = await GetSelectRole(model.RoleId, db);
if (await db.Users.AnyAsync(x => x.UserName == model.UserName))
{
return(Json(Js.Error(TD.Global.UserNameUsed)));
}
var data = new User(model.UserName);
data.CantSay = model.CantSay;
data.Sign = model.Sign;
data.Email = model.Email;
data.PasswordHash = model.Password.ToEncrypt();
db.Users.Add(data);
var str = await db.SaveMessageAsync();
if (str != null)
{
return(Json(str.GetError()));
}
foreach (var item in lstSelect)
{
if (!data.Roles.Any(x => x.RoleId == item))
{
data.Roles.Add(new IdentityUserRole
{
UserId = data.Id,
RoleId = item
});
}
}
db.Entry(data).State = EntityState.Modified;
str = await db.SaveMessageAsync();
if (str != null)
{
return(Json(str.GetError()));
}
return(Json(Js.SuccessRedirect(TD.Global.UserInserted, "/admin/users")));
}
public static void AddAverageData(ArrayList al)
{
using (var db = new TDContext())
{
Average average = new Average();
average.Date = (DateTime)al[0];
average.AvgTemp = (double)al[1];
average.AvgHum = (int)al[2];
average.AvgTempInside = (double)al[3];
average.AvgHumInside = (int)al[4];
db.Add(average);
//db.SaveChanges();
};
}
public async Task <ActionResult> VersionFeatureApps(string AppId, LicenseType?Version)
{
var db = new TDContext();
if (string.IsNullOrEmpty(AppId) || Version == null)
{
return(View());
}
App app = db.Apps.Find(AppId);
if (app == null)
{
return(View());
}
var appFeatureApps = db.AppFeatures.Where(x => x.AppId == app.Id);
var lst = typeof(LicenseType).GetDictionary();
foreach (var item in appFeatureApps.ToList())
{
foreach (var t in lst)
{
var data = db.VersionFeatureApps.Find(item.AppId, (LicenseType)t.Key, item.FeatureAppId);
if (data == null)
{
data = new VersionFeature
{
AppId = item.AppId,
Version = (LicenseType)t.Key,
FeatureAppId = item.FeatureAppId,
Content = item.Content
};
db.VersionFeatureApps.Add(data);
var str = await db.SaveDatabase();
}
}
}
var partnerApps = db.VersionFeatureApps.Include(X => X.App).Include(x => x.FeatureApp).Where(x => x.AppId == AppId && x.Version == Version).OrderBy(x => x.FeatureApp.Name);
var model = new List <VersionFeatureEditModel>();
ViewBag.AppId = app.Id;
ViewBag.Version = Version;
foreach (var item in partnerApps)
{
model.Add(new VersionFeatureEditModel(item));
}
return(PartialView(model));
}
public static void FindAverageValues(List <DateTime> list, string environment)
{
foreach (var l in list)
{
ArrayList al = new ArrayList();
double sumTempOut = 0; //Håller koll på summan av temp
double sumTempIn = 0;
int sumHumOut = 0; //Håller koll på summan av luftfuktighet
int sumHumIn = 0;
double amountOut = 0; //För att kunna få ut medeltal
double amountIn = 0;
int i = 0;
using (var db = new TDContext())
{
foreach (var t in db.Temperatures)
{
if (l == t.Date.Value.Date)
{
if (t.Environment == "Ute")
{
sumTempOut += t.Temp.Value;
sumHumOut += t.Humidity.Value;
amountOut++;
}
if (t.Environment == "Inne")
{
sumTempIn += t.Temp.Value;
sumHumIn += t.Humidity.Value;
amountIn++;
}
}
}
}
al.Add(l);
al.Add(Math.Round(sumTempOut / amountOut, 1));
al.Add(sumHumOut / Convert.ToInt32(amountOut));
al.Add(Math.Round(sumTempIn / amountIn, 1));
al.Add(sumHumIn / Convert.ToInt32(amountIn));
AddAverageData(al);
}
}
internal static void FindSelectedDate(string selectedDate, string environment)
{
using (var db = new TDContext())
{
var res1 = db.Averages.Where(a => a.Date.ToString().Contains(selectedDate)); // Få in INNE
int notFound = 0;
foreach (var r in res1)
{
Console.WriteLine($"Datum:{r.Date.ToShortDateString()}\tMedeltemperatur: {r.AvgTemp}");
notFound++;
}
if (notFound == 0)
{
Console.WriteLine("Det finns inte väderdata för det valda datumet");
}
}
}
public static List <DateTime> GetDateTimes()
{
List <DateTime> list = new List <DateTime>();
using (var db = new TDContext())
{
foreach (var t in db.Temperatures)
{
//yyyy-mm-dd 00:00:00
t.Date = t.Date.Value.Date;
if (!(list.Contains(t.Date.Value)))
{
list.Add(t.Date.Value); //Lägger till varje datum EN gång
}
}
}
return(list);
}
internal static void SortTemp(bool environment)
{
using (var db = new TDContext())
{
var res = db.Averages.OrderByDescending(a => a.AvgTemp);
Console.Clear();
int i = 0;
foreach (var r in res)
{
Console.WriteLine($"Datum:{r.Date.ToShortDateString()}\tMedeltemperatur: {r.AvgTemp}");
i++;
if (i == 60)
{
break;
}
}
}
}
internal static void SortHum(bool environment)
{
using (var db = new TDContext())
{
var res = db.Averages.OrderBy(a => a.AvgHum);
Console.Clear();
int i = 0;
foreach (var r in res)
{
Console.WriteLine($"Datum:{r.Date.ToShortDateString()}\tMedelluftfuktighet: {r.AvgHum}%");
i++;
if (i == 60)
{
break;
}
}
}
}
async Task <IEnumerable <string> > GetSelectRole(string[] roleId, TDContext db)
{
var lst = new List <string>();
var roleDB = new RoleDB(db);
if (roleId != null && roleId.Length > 0)
{
for (int i = 0, j = roleId.Length; i < j; i++)
{
var item = await roleDB.FindOrCreate(roleId[i]);
if (item != null)
{
lst.Add(item.Id);
}
}
}
return(lst);
}
public List <UserAppView> Login(string UserName, string Password, string AppKey)
{
var publicIP = GetClientIp(this.Request);
var dePassword = Password.ToDecrypt();
var user = UserManager.FindByName(UserName);
if (user == null || user.PasswordHash.ToDecrypt() != dePassword)
{
return(null);
}
var db = new TDContext();
var app = db.Apps.Find(AppKey);
if (app == null)
{
return(null);
}
var userApps = db.UserApps.Where(x => x.UserId == user.Id && x.AppId == AppKey);
var lst = new List <UserAppView>();
foreach (var item in userApps)
{
var partner = db.Partners.Find(item.ClientId);
var clientApp = db.ClientApps.Find(item.ClientId, AppKey);
UserAppView addItem = new UserAppView()
{
ClientId = item.ClientId,
UserId = item.UserId,
AppId = item.AppId,
UserName = user.UserName,
Password = user.PasswordHash,
AppName = app.Name,
PartnerName = partner.Name,
Database = clientApp.Database,
Port = clientApp.Port
};
lst.Add(addItem);
}
return(lst);
}
public static void Insert(List <string> lines)
{
string[] col;
foreach (string line in lines)
{
col = line.Split(","); //date[0], environment[1], Temp [2], Humdidity[3]
using (var db = new TDContext())
{
Temperature temperature = new Temperature();
temperature.Date = DateTime.Parse(col[0]);
temperature.Environment = col[1];
temperature.Temp = double.Parse(col[2], CultureInfo.InvariantCulture);
temperature.Humidity = int.Parse(col[3]);
db.Add(temperature);
//db.SaveChanges();
};
}
}
static void AddMoldData(List <Temperature> temperatureList)
{
//Mögelrisk = ((fuktighet - 78) * (temperatur / 15)) / 0,22
using (var db = new TDContext())
{
foreach (var row in temperatureList)
{
double risk = 0;
/* double Hum2 = Convert.ToDouble(row.Humidity.Value)*/
risk = ((row.Humidity.Value - 78) * (row.Temp.Value / 15)) / 0.22;
MoldRisk moldRisk = new MoldRisk();
moldRisk.Date = row.Date.Value;
moldRisk.MoldPercentage = Math.Round(risk, 4);
db.Add(moldRisk);
}
//db.SaveChanges();
}
}
internal static void MeteorologicalAutumn()
{
//då dygnsmedeltemperaturen som högst är 0 grader Celsius minst 5 dagar i sträck.
//Om dygnsmedeltemperaturen är lägre än 10,0°C fem dygn i följd, säger vi att hösten anlände det första av dessa dyg
int daysInRow = 0;
List <Average> datesInRow = new List <Average>();
using (var db = new TDContext())
{
var res = from a in db.Averages
where a.Date.Month == 08 || a.Date.Month == 09 || a.Date.Month == 10
orderby a.Date
select a;
Console.Clear();
foreach (var row in res)
{
if (row.AvgTemp < 10)
{
daysInRow++;
datesInRow.Add(row);
if (daysInRow == 5)
{
Console.WriteLine($"Det finns inte väderdata för alla datum år 2016 i databasen,\n" +
$" men om man utgår från de datum som finns så " +
$"började\nden meteorologiska hösten :{datesInRow[0].Date.Date}");
Console.ReadKey();
}
}
else
{
datesInRow.Clear();
daysInRow = 0;
}
}
}
}
