public static ResultModel AuthorizeUser(string email, string password)
{
try {
using (var db = new TestDbEntities()) {
if (string.IsNullOrEmpty(email) || string.IsNullOrEmpty(password))
{
return(new ResultModel("Data is wrong"));
}
var user = db.UserProfile.FirstOrDefault(a => a.Email.ToLower() == email.ToLower());
if (user == null)
{
return(new ResultModel("User wasn't found"));
}
var hash = GetHash(password);
if (user.AuthInfo.PasswordMd5 != hash)
{
return(new ResultModel("Password is wrong"));
}
return(new ResultModel(true, user?.Apikeys?.Apikey ?? ""));
}
} catch (Exception ex) {
return(new ResultModel(ex.Message));
}
}
protected bool HasAccount(string accountName)
{
using (var context = new TestDbEntities())
{
return(context.Accounts.Any(acc => acc.Name == accountName));
}
}
/// <summary>
/// получаем всю инфу по пользователю
/// </summary>
public static ResultModel GetUserInfo(string apikey)
{
try {
using (var db = new TestDbEntities()) {
//var apikeys = db.Apikeys.ToList();
//db.Apikeys.RemoveRange(apikeys);
//db.SaveChanges();
//var auths = db.AuthInfo.ToList();
//db.AuthInfo.RemoveRange(auths);
//db.SaveChanges();
//var users = db.UserProfile.ToList();
//db.UserProfile.RemoveRange(users);
//db.SaveChanges();
var ap = db.Apikeys.FirstOrDefault(a => a.Apikey == apikey);
var user = ap?.UserProfile;
if (user == null)
{
return(new ResultModel("Apikey is wrong"));
}
var result = new AuthUserInfoModel(db, user);
return(new ResultModel(result));
}
} catch (Exception ex) {
return(new ResultModel(ex.Message));
}
}
public void SaveInformation()
{
using (TestDbEntities test = new TestDbEntities())
{
test.FNs.Add(new FN
{
FirstName = TabOneUserControl.FirstName
});
test.LNs.Add(new LN
{
LastName = TabTwoUserControl.LastName
});
try
{
test.SaveChanges();
Debug.Print("SAVED CHANGES!");
}
catch (DbEntityValidationException ex)
{
foreach (var validationErrors in ex.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
Trace.TraceInformation(
"Class: {0}, Property: {1}, Error: {2}",
validationErrors.Entry.Entity.GetType().FullName,
validationError.PropertyName,
validationError.ErrorMessage);
}
}
}
}
}
public List <string> GetFullTime()
{
using (var context = new TestDbEntities())
{
return(GetData(context.FTContractors.AsQueryable()));
}
}
public IHttpActionResult SaveScore(DailyScore score)
{
using (TestDbEntities db = new TestDbEntities())
{
var entry = db.Scores.FirstOrDefault();
if (entry != null)
{
List <DailyScore> scores = JsonConvert.DeserializeObject <List <DailyScore> >(entry.JsonData ?? string.Empty);
scores.Add(score);
entry.JsonData = JsonConvert.SerializeObject(scores);
db.SaveChanges();
}
else
{
Score newScore = new Score();
List <DailyScore> scores = new List <DailyScore>();
scores.Add(score);
newScore.JsonData = JsonConvert.SerializeObject(scores);
db.Scores.Add(newScore);
db.SaveChanges();
}
return(Ok());
}
}
public static IList <TProduct> GetAllProducts()
{
using (TestDbEntities db = new TestDbEntities())
{
return(db.TProducts.ToList());
}
}
/// <summary>
/// получаем данные по конкретному платежу
/// </summary>
public ResultModel GetInfoAbountPayment(int paymentId)
{
try {
using (var db = new TestDbEntities()) {
if (UserId == -1)
{
return(new ResultModel(Error));
}
var payment = db.Payments.FirstOrDefault(a => a.PaymentId == paymentId);
if (payment == null)
{
return(new ResultModel("PaymentId is wrong"));
}
if (payment.UserId != UserId && payment.UserForId != UserId)
{
return(new ResultModel("No rules for access"));
}
var result = new PaymentModel();
if (payment.UserId == UserId)
{
result = new PaymentModel(db, payment, true);
}
else
{
result = new PaymentModel(db, payment, false);
}
return(new ResultModel(result));
}
} catch (Exception ex) {
return(new ResultModel(ex.Message));
}
}
public PaymentModel(TestDbEntities db,
Payments payment,
bool output)
{
var sTime = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
var userFor = db.UserProfile
.FirstOrDefault(a => a.UserId == payment.UserForId);
var user = db.UserProfile
.FirstOrDefault(a => a.UserId == payment.UserId);
if (userFor == null || user == null)
{
return;
}
UserFor = new AuthUserInfoModel(db, userFor);
PaymentId = payment.PaymentId;
ToAccountNumber = db.UserProfile
.FirstOrDefault(a => a.UserId == payment.UserId)
?.AccountNumber ?? "";
PaymentDateUnix = payment.PaymentDate.ToString();
PaymentName = payment.Name;
PaymentNote = payment.Note;
Sum = payment.Sum;
Status = payment.Status;
UserId = payment.UserId;
Output = output;
UserFristName = user.FirstName;
UserSecondName = user.SecondName;
UserForId = userFor.UserId;
ForAccountNumber = userFor.AccountNumber;
}
private void LoadTestRecords()
{
int i = 0;
int c = 100;
using (Test.Db.TestDbEntities db = new TestDbEntities())
{
db.Headers.SqlQuery("TRUNCATE TABLE [dbo].[Headers]");
}
while (i <= (c - 1))
{
using (Test.Db.TestDbEntities db = new TestDbEntities())
{
Header h = new Header();
h.PublicId = Guid.NewGuid();
h.Active = true;
h.CreateDate = DateTime.Now;
h.UpdateDate = DateTime.Now;
db.Headers.Add(h);
db.SaveChanges();
}
i++;
}
}
/// <summary>
/// получаем список платежей
/// </summary>
public ResultModel GetPaymentsList()
{
try {
using (var db = new TestDbEntities()) {
if (UserId == -1)
{
return(new ResultModel(Error));
}
var user = db.UserProfile.First(a => a.UserId == UserId);
if (user == null)
{
return(new ResultModel("User wasn't found"));
}
var from = db.Payments.Where(a => a.UserId == UserId).ToList();
var to = db.Payments.Where(a => a.UserForId == UserId).ToList();
var result = new List <PaymentModel>();
from.ForEach(payment => {
result.Add(new PaymentModel(db, payment, true));
});
to.ForEach(payment => {
result.Add(new PaymentModel(db, payment, false));
});
return(new ResultModel(result));
}
} catch (Exception ex) {
Error = ex.Message;
return(new ResultModel(Error));
}
}
public static bool Login(string username, string password)
{
using (TestDbEntities db = new TestDbEntities())
{
return(db.TUsers.Any(user => user.Username.Equals(username, StringComparison.OrdinalIgnoreCase) &&
user.Password == password));
}
}
public static bool Register(TUser newUser)
{
using (TestDbEntities db = new TestDbEntities())
{
db.TUsers.Add(newUser);
return(db.SaveChanges() > 0);
}
}
public List <string> GetPartTime()
{
using (var context = new TestDbEntities())
{
var rep = new Repository();
return(rep.GetData(context.PTContractors.AsQueryable()));
}
}
// GET: api/Employee
public IEnumerable <Employee> Get()
{
using (var context = new TestDbEntities())
{
var data = context.Employees.ToList <Employee>();
return(data);
}
}
//
// GET: /Default1/Delete/5
public ActionResult Delete(int Id)
{
TestDbEntities obj = new TestDbEntities();
var data = obj.TblTests.FirstOrDefault(x => x.ID == Id);
obj.TblTests.DeleteObject(data);
obj.SaveChanges();
return(RedirectToAction("Index"));
}
public IHttpActionResult Login()
{
string username = Thread.CurrentPrincipal.Identity.Name;
using (TestDbEntities db = new TestDbEntities())
{
var user = db.TUsers.Where(x => x.Username == username).SingleOrDefault();
return(Json(user));
}
}
public AuthUserInfoModel(TestDbEntities db, UserProfile user)
{
Apikey = user.Apikeys.Apikey ?? "";
Budget = user.Budget;
Email = user.Email;
FirstName = user.FirstName;
SecondName = user.SecondName;
AccountNumber = user.AccountNumber;
UserId = user.UserId;
}
public static List <string> GetAllNames()
{
List <string> result = new List <string>();
using (TestDbEntities db = new TestDbEntities())
{
db.Names.ToList().ForEach(x => result.Add(x.Name));
}
return(result);
}
protected bool HasTransaction(string accountName, string transactionDescription)
{
using (var context = new TestDbEntities())
{
return
(context.Accounts.Any(
acc =>
acc.Name == accountName &&
acc.Transactions.Any(tr => tr.Description == transactionDescription)));
}
}
//
// GET: /Default1/Edit/5
public ActionResult Edit(int Id)
{
TestDbEntities obj = new TestDbEntities();
var data = obj.TblTests.FirstOrDefault(x => x.ID == Id);
var model = new TestUserModel()
{
Id = data.ID, Name = data.Name, Address = data.Address
};
return(View(model));
}
public IHttpActionResult Get()
{
//string username = Thread.CurrentPrincipal.Identity.Name;
using (TestDbEntities db = new TestDbEntities())
{
var products = db.TProducts.ToList();
return(Json(products));
}
}
/// <summary>
/// создаем платеж
/// </summary>
public ResultModel CreatePayment(CreatePaymentModel model)
{
try {
using (var db = new TestDbEntities()) {
if (UserId == -1)
{
return(new ResultModel(Error));
}
var user = db.UserProfile.First(a => a.UserId == UserId);
if (string.IsNullOrEmpty(model.AccountForNumber) || user.AccountNumber == model.AccountForNumber)
{
Error = "Account number is wrong";
return(new ResultModel(Error));
}
if (model.Sum == 0 || user.Budget < model.Sum)
{
Error = "Sum is wrong";
return(new ResultModel(Error));
}
var userFor = db.UserProfile.FirstOrDefault(a => a.AccountNumber == model.AccountForNumber);
if (userFor == null)
{
Error = "AccountNumber is wrong!";
UserId = -1;
return(new ResultModel(Error));
}
user.Budget = user.Budget - model.Sum;
userFor.Budget = userFor.Budget + model.Sum;
var payment = new Payments()
{
Name = model.PaymentName,
Note = model.PaymentNote ?? "",
PaymentDate = DateTime.Now,
Status = model.Status,
Sum = model.Sum,
UserForId = userFor.UserId,
UserId = UserId
};
db.Payments.Add(payment);
db.SaveChanges();
return(new ResultModel(true));
}
} catch (Exception ex) {
Error = ex.Message;
return(new ResultModel(Error));
}
}
public static Task <TUser> LoginAsync(string username, string password)
{
return(Task.Run(() =>
{
using (TestDbEntities db = new TestDbEntities())
{
return db.TUsers
.Where(user => user.Username == username && user.Password == password)
.SingleOrDefault();
}
}));
}
public ResultModel FindPayments(int type, string data)
{
try {
using (var db = new TestDbEntities()) {
var typeEnum = (FindTypesEnum)type;
var payments = GetPaymentsList();
if (string.IsNullOrEmpty(data))
{
return(payments);
}
if (!payments.Status || payments.Data == null)
{
return(new ResultModel(false));
}
var list = (List <PaymentModel>)payments.Data;
var result = new List <PaymentModel>();
switch (typeEnum)
{
case FindTypesEnum.ByName: {
result = list?
.Where(a => a.PaymentName.Trim().ToLower() == data.Trim().ToLower())?
.ToList();
return(new ResultModel(result));
}
case FindTypesEnum.ByAccountFor: {
result = list?
.Where(a => (a.ForAccountNumber?.Trim().ToLower() ?? "") == data.Trim().ToLower())?
.ToList();
return(new ResultModel(result));
}
case FindTypesEnum.ByAccountTo: {
result = list?
.Where(a => (a.ToAccountNumber?.Trim().ToLower() ?? "") == data.Trim().ToLower())?
.ToList();
return(new ResultModel(result));
}
default: {
return(new ResultModel(result));
}
}
}
} catch (Exception ex) {
return(new ResultModel(ex.Message));
}
}
public JsonResult <List <DailyScore> > HighScores()
{
using (TestDbEntities db = new TestDbEntities())
{
var entry = db.Scores.FirstOrDefault();
if (entry != null)
{
List <DailyScore> score = JsonConvert.DeserializeObject <List <DailyScore> >(entry.JsonData);
return(Json <List <DailyScore> >(score));
}
else
{
return(Json <List <DailyScore> >(null));
}
}
}
public void SetUpBase()
{
using (var context = new TestDbEntities())
{
context.Transactions.RemoveRange(context.Transactions.ToList());
context.Accounts.RemoveRange(context.Accounts.ToList());
context.SaveChanges();
}
using (var context = new CodeFirstTestDbContext())
{
context.Users.RemoveRange(context.Users.ToList());
context.Roles.RemoveRange(context.Roles.ToList());
context.SaveChanges();
}
}
//
// GET: /Default1/
public ActionResult Index()
{
TestDbEntities obj = new TestDbEntities();
List <TestUserModel> model = new List <TestUserModel>();
var data = obj.TblTests.ToList();
foreach (var item in data)
{
model.Add(new TestUserModel()
{
Address = item.Address, Id = item.ID, Name = item.Name
});
}
return(View(model));
}
public static NameDto GetById(long recordId)
{
NameDto result = null;
using (TestDbEntities db = new TestDbEntities())
{
var dbRecord = db.Names.Find(recordId);
if (dbRecord != null)
{
result = new NameDto
{
Name = dbRecord.Name
};
MapBaseProperties(dbRecord, result);
}
}
return(result ?? default);
}
public static NameDto FindByName(string queryName)
{
NameDto result = null;
using (TestDbEntities db = new TestDbEntities())
{
var dbRecord = db.Names.FirstOrDefault(x => x.Name.Equals(queryName));
if (dbRecord != null)
{
result = new NameDto
{
Name = dbRecord.Name
};
MapBaseProperties(dbRecord, result);
}
}
return(result ?? default);
}
