public List <Admin> getAll()
{
using (AdminEntities db = new AdminEntities())
{
return(db.Admins.ToList());
}
}
public Admin GetbyUserName(string username)
{
using (AdminEntities db = new AdminEntities())
{
return(db.Admins.Find(username));
}
}
public async Task <TenantEntity> GetTenantAsync(string engagementAccount)
{
using (var ctx = new AdminEntities(this.connectionString))
{
return(await ctx.Tenants.SingleOrDefaultAsync(t => t.AccountName == engagementAccount));
}
}
public async Task <Tenant> UpdateTenantAsync(
Tenant tenant)
{
using (var ctx = new AdminEntities(this.connectionString))
{
var entity = await ctx.Tenants.GetAsync(
tenant.SubscriptionId,
tenant.ResourceGroupName,
tenant.AccountName);
// Update-able properties: Tags, State and Address
entity.Tags = JsonConvert.SerializeObject(tenant.Tags);
entity.State = tenant.State.ToString();
entity.Address = tenant.Address;
entity.LastModified = DateTime.UtcNow;
if (tenant.IsDisabled.HasValue)
{
entity.IsDisabled = tenant.IsDisabled;
}
await ctx.SaveChangesAsync();
return(entity.ToTenant());
}
}
public JsonResult SaveUrlaub(Events e)
{
var status = false;
using (AdminEntities dc = new AdminEntities())
{
if (e.EventID > 0)
{
///Update Urlaub
var v = dc.Events.Where(a => a.EventID == e.EventID).FirstOrDefault();
if (v != null)
{
v.Subject = e.Subject;
v.Start = e.Start;
v.End = e.End;
v.Description = e.Description;
v.ThemeColor = e.ThemeColor;
}
}
else
{
dc.Events.Add(e);
}
dc.SaveChanges();
status = true;
}
return(new JsonResult {
Data = new { status = status }
});
}
public bool InsertAdmin(Admin ad)
{
using (AdminEntities db = new AdminEntities())
{
db.Admins.Add(ad);
int row = db.SaveChanges();
return(row > 0);
}
}
public JsonResult AjaxMethod()
{
using (AdminEntities entities = new AdminEntities())
{
List <role> roles = (from role in entities.roles
select role).ToList();
return(Json(roles));
}
}
public JsonResult AjaxMethod()
{
using (AdminEntities entities = new AdminEntities())
{
List <town> towns = (from town in entities.towns
select town).ToList();
return(Json(towns));
}
}
public ActionResult GetList()
{
//Server Side Parameter
int start = Convert.ToInt32(Request["start"]);
int length = Convert.ToInt32(Request["length"]);
string searchValue = Request.Form.GetValues("search[value]")[0];
string sortColumnName = Request.Form.GetValues("columns[" +
Request.Form.GetValues("order[0][column]").FirstOrDefault() + "][name]").FirstOrDefault();
string sortDirection = Request["order[0][dir]"];
List <userinfo> userinfoe = new List <userinfo>();
int totalrecord = userinfoe.Count;
using (AdminEntities db = new AdminEntities())
{
userinfoe = (from p in db.userinfoes
join f in db.roles
on p.RoleID equals f.RoleID
join a in db.accountstatus
on p.AccountStatusID equals a.AccountStatusID
where (p.FullName.ToLower() != null)
select new
{
Id = p.userinfoID,
Username = p.Username,
FullName = p.FullName,
status = a.AccountStatus,
Rolename = f.RoleName
}).ToList()
.Select(x => new userinfo()
{
userinfoID = x.Id,
Username = x.Username,
FullName = x.FullName,
status = x.status,
Rolename = x.Rolename
}).ToList <userinfo>();
// userinfoe = db.userinfoes.Where(x => x.FullName.ToLower() != null).ToList<userinfo>();
if (!string.IsNullOrEmpty(searchValue))
{
userinfoe = userinfoe.
Where(x => x.Username.ToLower().Contains(searchValue.ToLower()) || x.FullName.ToLower().Contains(searchValue.ToLower()) || x.Rolename.Contains(searchValue.ToLower()) || x.status.Contains(searchValue.ToLower())).ToList <userinfo>();
}
int totalrowsafterfiltering = userinfoe.Count;
// sorting
userinfoe = userinfoe.OrderBy(sortColumnName + " " + sortDirection).ToList <userinfo>();
// pagination
userinfoe = userinfoe.Skip(start).Take(length).ToList <userinfo>();
return(Json(new { data = userinfoe, draw = Request["draw"], recordsTotal = totalrecord, recordsFiltered = totalrowsafterfiltering }, JsonRequestBehavior.AllowGet));
}
}
public async Task <bool> AccountExistsAsync(
string accountName)
{
using (var ctx = new AdminEntities(this.connectionString))
{
return(await ctx.Tenants
.AnyAsync(e =>
e.AccountName == accountName));
}
}
/// <summary>
/// Methode gibt alle Urlaubs (Events) als JSON zurück
/// </summary>
/// <returns></returns>
public JsonResult GetUrlaubs()
{
using (AdminEntities dc = new AdminEntities())
{
var Urlaubs = dc.Events.ToList();
return(new JsonResult {
Data = Urlaubs, JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
}
public bool UpdateAdmin(Admin ad)
{
using (AdminEntities db = new AdminEntities())
{
db.Admins.Attach(ad);
db.Entry(ad).State = System.Data.Entity.EntityState.Modified;
int row = db.SaveChanges();
return(row > 0);
}
}
public bool DeleteAdmin(Admin ad)
{
using (AdminEntities db = new AdminEntities())
{
db.Admins.Attach(ad);
db.Admins.Remove(ad);
int a = db.SaveChanges();
return(a > 0);
}
}
public async Task <QuotaEntity> GetQuotaAsync(
string engagementAccount,
string quotaName)
{
using (var ctx = new AdminEntities(this.connectionString))
{
return(await ctx.Quotas.SingleOrDefaultAsync(
q => q.AccountName == engagementAccount &&
q.QuotaName == quotaName));
}
}
public ActionResult AddOrEdit(Admin_Geschäftfuehrer userModel)
{
using (AdminEntities model = new AdminEntities())
{
model.Admin_Geschäftfuehrer.Add(userModel);
model.SaveChanges();
}
ModelState.Clear();
ViewBag.SuccessMessage = "Registration Successful ";
return(View("AddOrEdit", new Admin_Geschäftfuehrer()));
}
public IEnumerable <Tenant> ListTenants(
string subscriptionId)
{
using (var ctx = new AdminEntities(this.connectionString))
{
return(ctx.Tenants
.Where(e =>
e.SubscriptionId == subscriptionId)
.ToList()
.Select(e => e.ToTenant()));
}
}
public async Task <int> PullQuotaRemindingAsync(
QuotaMetadata metadata)
{
using (var ctx = new AdminEntities(this.connectionString))
{
var entity = await ctx.Quotas.SingleOrDefaultAsync(t => t.AccountName == metadata.AccountName && t.QuotaName == metadata.QuotaName);
if (entity == null)
{
throw new ResourceNotFoundException($"No quota {metadata.AccountName}/{metadata.QuotaName}");
}
return(metadata.IsCurrentSlot(entity.LastUpdatedTime) ? entity.Remaining : entity.Quota);
}
}
public async Task <Tenant> GetTenantAsync(
string subscriptionId,
string resourceGroupName,
string accountName)
{
using (var ctx = new AdminEntities(this.connectionString))
{
var entity = await ctx.Tenants.GetAsync(
subscriptionId,
resourceGroupName,
accountName);
return(entity.ToTenant());
}
}
public ActionResult Create([Bind(Include = "TownID,TownName,AccountStatusID,ZoneId")] town town)
{
if (ModelState.IsValid)
{
using (db = new AdminEntities())
{
town.AccountStatusID = 1;
db.towns.Add(town);
db.SaveChanges();
}
return(RedirectToAction("Index"));
}
ViewBag.ZoneId = new SelectList(db.zones, "ZoneID", "ZoneName", town.ZoneId);
return(View(town));
}
public ActionResult Autherize(Admin_Geschäftfuehrer AdminModel)
{
using (AdminEntities db = new AdminEntities())
{
var userDetails = db.Admin_Geschäftfuehrer.Where(x => x.Username == AdminModel.Username && x.Password == AdminModel.Password).FirstOrDefault();
if (userDetails == null)
{
AdminModel.LoginErrorMessage = "Überprüfen Sie Ihre Daten nach bitte ! ";
return(View("Index", AdminModel));
}
else
{
Session["UserID"] = userDetails.Admin_id;
}
return(View("~/Views/FirstLayout/Index.cshtml", AdminModel));
}
}
public async Task RemoveQuotaAsync(
string engagementAccount,
string quotaName)
{
using (var ctx = new AdminEntities(this.connectionString))
{
var existing = await ctx.Quotas.SingleOrDefaultAsync(
q => q.AccountName == engagementAccount &&
q.QuotaName == quotaName);
if (existing != null)
{
ctx.Quotas.Remove(existing);
await ctx.SaveChangesAsync();
}
}
}
public async Task DeleteTenantAsync(
string subscriptionId,
string resourceGroupName,
string accountName)
{
using (var ctx = new AdminEntities(this.connectionString))
{
var entity = await ctx.Tenants.GetAsync(
subscriptionId,
resourceGroupName,
accountName);
ctx.Tenants.Remove(entity);
var quotaEntities = ctx.Quotas.Where(e => e.AccountName == accountName);
ctx.Quotas.RemoveRange(quotaEntities);
await ctx.SaveChangesAsync();
}
}
private async Task <Tenant> WithTenantDescriptionAsync(
string subscriptionId,
string resourceGroupName,
string accountName,
Action <TenantDescription> action,
int maxRetry)
{
var retry = 0;
while (true)
{
using (var ctx = new AdminEntities(this.connectionString))
{
var entity = await ctx.Tenants.GetAsync(
subscriptionId,
resourceGroupName,
accountName);
var description = JsonConvert.DeserializeObject <TenantDescription>(entity.ResourceDescription);
action(description);
entity.ResourceDescription = JsonConvert.SerializeObject(description);
entity.LastModified = DateTime.UtcNow;
try
{
await ctx.SaveChangesAsync();
return(entity.ToTenant());
}
catch (DbUpdateConcurrencyException)
{
if (++retry >= maxRetry)
{
throw new ConcurrencyException("Failed due to concurrency update on the same entity. Please try it again later");
}
}
}
}
}
public ActionResult Login(Customer user)
{
if (ModelState.IsValid)
{
using (UserEntities db = new UserEntities())
{
var usr = db.Customer.Where(u => u.Email == user.Email && u.Password == user.Password).FirstOrDefault();
if (usr == null)
{
using (AdminEntities AdminDb = new AdminEntities())
{
var admin = AdminDb.Admin.Where(u => u.Email == user.Email && u.Password == user.Password).FirstOrDefault();
if (admin == null)
{
ModelState.AddModelError("", "Username or password is wrong");
return(View("Login"));
}
else
{
Session["AdminId"] = admin.id;
Session["AdminName"] = admin.Name;
return(RedirectToAction("AdminLogin"));
}
}
}
else
{
Session["UserId"] = usr.id;
Session["Username"] = usr.Name;
Session["Surname"] = usr.Surname;
return(RedirectToAction("CustomerLogin"));
}
}
}
else
{
return(View("Login"));
}
}
public async Task PushQuotaRemindingAsync(
QuotaMetadata metadata,
int reminding,
DateTime synchronizeTime)
{
using (var ctx = new AdminEntities(this.connectionString))
{
var entity = await ctx.Quotas.SingleOrDefaultAsync(t => t.AccountName == metadata.AccountName && t.QuotaName == metadata.QuotaName);
if (entity == null)
{
throw new ResourceNotFoundException($"No quota {metadata.AccountName}/{metadata.QuotaName}");
}
if (metadata.IsCurrentOrNewerSlot(entity.LastUpdatedTime))
{
entity.Remaining = reminding;
entity.LastUpdatedTime = synchronizeTime;
await ctx.SaveChangesAsync();
}
}
}
public ActionResult Index(Admin u)
{
// this action is for handle post (login)
if (ModelState.IsValid) // this is check validity
{
using (AdminEntities dc = new AdminEntities())
{
var v = dc.Admins.Where(a => a.Username.Equals(u.Username) && a.Password.Equals(u.Password)).FirstOrDefault();
if (v != null)
{
Session["LogedUserFullname"] = v.Username.ToString();
return(Redirect("/AfterAdminLogin/Index"));
}
else
{
ModelState.AddModelError("", "Invalid login credentials.");
}
}
}
return(View(u));
}
public JsonResult DeleteUrlaub(int EventID)
{
/// <summary>
/// Implementierung der DeleteEvent Methode
/// </summary>
/// <returns></returns>
var status = false;
using (AdminEntities dc = new AdminEntities())
{
var v = dc.Events.Where(a => a.EventID == EventID).FirstOrDefault();
if (v != null)
{
dc.Events.Remove(v);
dc.SaveChanges();
status = true;
}
}
return(new JsonResult {
Data = new { status = status }
});
}
public async Task <QuotaEntity> CreateOrUpdateQuotaAsync(
string engagementAccount,
string quotaName,
int quota)
{
using (var ctx = new AdminEntities(this.connectionString))
{
var existing = await ctx.Quotas.SingleOrDefaultAsync(
q => q.AccountName == engagementAccount &&
q.QuotaName == quotaName);
var now = DateTime.UtcNow;
if (existing != null)
{
existing.Quota = quota;
existing.LastUpdatedTime = now;
}
else
{
existing = new QuotaEntity
{
AccountName = engagementAccount,
QuotaName = quotaName,
Remaining = quota,
Quota = quota,
CreatedTime = now,
LastUpdatedTime = now
};
ctx.Quotas.Add(existing);
}
await ctx.SaveChangesAsync();
return(existing);
}
}
public AdminEngController()
{
_db = new AdminEntities();
}
// GET: UrlaubAdmin
public UrlaubAdminController()
{
_db = new AdminEntities();
}
