public IHttpActionResult DeleteKund(int id)
{
Kund kund = db.Kund.Find(id);
if (kund == null)
{
Logger.Error("Gick inte att hitta kunden");
return(NotFound());
}
db.Kund.Remove(kund);
db.SaveChanges();
return(Ok(kund));
}
public async Task <bool> AddBonusPointsToUser(Kund kund, int bonusPoints)
{
var succeeded = false;
var user = await FetchCurrentUser();
if (await IsUserPremium(user) == true)
{
kund.BonusPoints += bonusPoints;
kund.UserId = user.Id;
_userRepository.Update(kund);
succeeded = true;
return(succeeded);
}
return(succeeded);
}
public async Task <bool> UpdateCustomerAsync(Kund customer)
{
var getCustResult = await(from cust in _context.Kund
where cust.IdentityId == customer.IdentityId
select cust).SingleOrDefaultAsync();
if (getCustResult == null)
{
return(false);
}
var result = await _context.SaveChangesAsync();
return(await Task.FromResult(result == 1));
}
public void UpdateKund(Kunder K, Kund JSon)
{
var Model = new Kunder();
Model.Kund = JSon;
var Original = _Repository.Kund.SingleOrDefault(O => O.KundId == Model.Kund.KundId);
K.Kund.KundId = Original.KundId;
if (Original != null)
{
_Repository.Entry(Original).CurrentValues.SetValues(K.Kund);
_Repository.SaveChanges();
}
}
public async Task <bool> RemoveBonusPointsFromUser(Kund kund)
{
var succeeded = false;
var user = await FetchCurrentUser();
if (await IsUserPremium(user) == true && kund.BonusPoints >= 100)
{
kund.BonusPoints -= 100;
kund.UserId = user.Id;
_userRepository.Update(kund);
succeeded = true;
return(succeeded);
}
return(succeeded);
}
public async Task <bool> UpdatePassword(ApplicationUser user, Kund customer, string currentPassword, string newPassword)
{
var isPassValid = await CheckPassword(user, currentPassword);
if (isPassValid == true)
{
customer.UserId = user.Id;
await _userManager.ChangePasswordAsync(user, currentPassword, newPassword);
return(true);
}
else
{
return(false);
}
}
private void lvwKunder_SelectedIndexChanged(object sender, EventArgs e)
{
try
{
tbxNamn.Clear();
tbxPersonligID.Clear();
string kundID = lvwKunder.SelectedItems[0].Text;
Kund kund = kundList.Find(kundID);
tbxNamn.Text = kund.Namn;
tbxPersonligID.Text = kund.PersonligID;
lblKund.Text = kund.Namn;
}
catch (Exception)
{
}
}
public ActionResult Register(Kund model)
{
var validUsername = Services.Services.Instance.CheckUserNameIsValid(model, Request);
if (ModelState.IsValid && validUsername == true)
{
var result = Services.Services.Instance.Identity("create", new LoginViewModel(), model, userManager, signInManager, Request, Response, User);
if (result == true)
{
return(RedirectToAction("Index", "Home"));
}
return(View("Register", model));
}
return(View(model));
}
public IActionResult AccountSide()
{
Kund currentUser = new Kund();
var isAvailble = HttpContext.Session.GetString("Users");
if (isAvailble != null)
{
currentUser = JsonConvert.DeserializeObject <Kund>(isAvailble);
return(View(currentUser));
}
else
{
ViewBag.Message = "Du måste vara inloggad för att kunna använda denna sida";
return(View(currentUser));
}
}
public ActionResult PutKund(Kund Kunden) /*Metoden kommer ifrån denna källa: https://www.tutorialsteacher.com/webapi/implement-put-method-in-web-api*/
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri("http://193.10.202.72/Kundservice/");
var putTask = client.PutAsJsonAsync <Kund>("Kunder/" + Kunden.InloggningsId, Kunden);
putTask.Wait();
var result = putTask.Result;
if (result.IsSuccessStatusCode)
{
return(RedirectToAction("GetKund"));
}
}
Logger.Error("Det gick inte att göra förändringen av kunden");
return(View(Kunden));
}
public IActionResult SaveChanges(Kund values)
{
if (ModelState.IsValid)
{
var kundDb = _context.Kund.SingleOrDefault(k => k.KundId == values.KundId);
_context.Entry(kundDb).CurrentValues.SetValues(values);
_context.SaveChanges();
var updatedValues = JsonConvert.SerializeObject(values);
HttpContext.Session.SetString("Users", updatedValues);
return(RedirectToAction("Account"));
}
ViewBag.Message = "Error";
return(RedirectToAction("Account"));
}
public async Task <IdentityResult> CreateUser(Kund customer, string username, string password)
{
var user = new ApplicationUser {
UserName = username, Email = customer.Email
};
var result = await _userManager.CreateAsync(user, password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, "RegularUser");
customer.UserId = user.Id;
_userRepository.Add(customer);
}
return(result);
}
public IActionResult RegisterNewCustomer(RegistrationModel newCustomer)
{
if (ModelState.IsValid)
{
var emptyCustomer = new Kund();
var customerToAdd = TransformRegistrationModelToKundEntity(emptyCustomer, newCustomer);
_context.Kund.Add(customerToAdd);
_context.SaveChanges();
return(View("Login"));
}
else
{
return(View());
}
}
// en metod för att lägga till data, lägga till en kund
public bool LäggTillKund(string Förnamn, string Efternamn, string Email, int Telefonnummer, string Gatuadress, int Postnummer, string Ort, out int kundid)
{
using (var context = new CykelAffärContext())
{
var nykund = new Kund(Förnamn, Efternamn, Email, Telefonnummer, Gatuadress, Postnummer, Ort);
context.Kunder.Add(nykund);
context.SaveChanges();
kundid = nykund.Kund_id;
return(true);
}
kundid = 0;
return(false);
}
public int FetchDiscountCartTotal(Kund kund)
{
var items = FetchCartItems();
var total = FetchCartTotal();
if (HasPointsForFreeDish(kund) == true)
{
total -= items.First().Pris;
}
if (items.Count >= 3)
{
total -= (int)Math.Round(total * 0.20);
}
return(total);
}
public IActionResult Login(Kund user)
{
var existingUser = _context.Kund.FirstOrDefault(u => u.AnvandarNamn == user.AnvandarNamn && u.Losenord == user.Losenord);
user = existingUser;
if (existingUser != null && existingUser.Losenord == user.Losenord)
{
var serializedValue = JsonConvert.SerializeObject(existingUser);
HttpContext.Session.SetString("User", serializedValue);
HttpContext.Session.SetString("UserId", user.KundId.ToString());
return(RedirectToAction("Index", "Home"));
}
ViewBag.Message = "Felaktig användarnamn eller lösenord!";
return(View());
}
public void KundFormView_InsertItem(Kund kund)
{
if (ModelState.IsValid)
{
try
{
Service.SaveKund(kund);
Session["Status"] = "Kunden lades till!";
Response.RedirectToRoute("Kunder", null);
Context.ApplicationInstance.CompleteRequest();
}
catch
{
ModelState.AddModelError(String.Empty, "Något gick fel när kunden skulle läggas till");
}
}
}
private void btnTaBortKund_Click(object sender, EventArgs e)
{
try
{
string kundID = lvwKunder.SelectedItems[0].Text;
Kund kund = kundList.Find(kundID);
kundList.Remove(kund);
tbxNamn.Clear();
tbxPersonligID.Clear();
}
catch
{
MessageBox.Show("Markera en kund för att radera!");
}
}
public async Task <IActionResult> Register(RegistrationViewModel user)
{
if (ModelState.IsValid)
{
var userIdentity = new ApplicationUser
{
UserName = user.AnvandarNamn
};
var result = await _userManager.CreateAsync(userIdentity, user.Losenord);
if (result.Succeeded)
{
if (user.RoleName == "Premium")
{
var resultRole = await _userManager.AddToRoleAsync(userIdentity, user.RoleName);
}
else
{
var resultRole = await _userManager.AddToRoleAsync(userIdentity, "Regular");
}
var reguser = new Kund
{
Namn = user.Namn,
Gatuadress = user.Gatuadress,
Postnr = user.Postnr,
Postort = user.Postort,
Email = user.Email,
Telefon = user.Telefon,
AnvandarNamn = user.AnvandarNamn,
Losenord = user.Losenord,
IdentityId = userIdentity.Id
};
_tomasos.Add(reguser);
await _tomasos.SaveChangesAsync();
await _signInManager.SignInAsync(userIdentity, isPersistent : false);
return(RedirectToAction("StartPage", "Home"));
}
}
return(View());
}
public async Task <IActionResult> Login(Kund user)
{
var model = new Kund();
if (user.AnvandarNamn != null && user.Losenord != null)
{
var result = await _signInManager.PasswordSignInAsync(user.AnvandarNamn, user.Losenord, true, false);
if (result.Succeeded)
{
//Om inloggningen gick bra visas startsidan
return(RedirectToAction("Start", "Home"));
}
}
return(View(model));
}
public IActionResult EditUserInfo(Kund updatedUser)
{
if (ModelState.IsValid)
{
var changes = updatedUser;
_context.Update(changes);
var succeded = _context.SaveChanges();
if (succeded > 0)
{
var serializedValue = JsonConvert.SerializeObject(changes);
HttpContext.Session.SetString("User", serializedValue);
return(RedirectToAction("Index", "Home"));
}
}
return(View());
}
public void UpdateUser(Kund user, int customerid)
{
using (TomasosContext db = new TomasosContext())
{
var customer = GetById(customerid);
customer.Namn = user.Namn;
customer.Gatuadress = user.Gatuadress;
customer.Postnr = user.Postnr;
customer.Postort = user.Postort;
customer.Email = user.Email;
customer.Telefon = user.Telefon;
customer.AnvandarNamn = user.AnvandarNamn;
customer.Losenord = user.Losenord;
db.Kund.Update(customer);
db.SaveChanges();
}
}
public bool CheckUserNameIsValid(Kund user, HttpRequest request)
{
var customer = CheckUserName(user);
var customerid = _cache.GetCustomerIDCache(request);
var cachecustomer = GetById(customerid);
if (customer == null)
{
return(true);
}
else if (user.AnvandarNamn == cachecustomer.AnvandarNamn)
{
return(true);
}
else
{
return(false);
}
}
public OrdersViewModel GetOrdersUnDelivered()
{
var model = new OrdersViewModel();
using (TomasosContext db = new TomasosContext())
{
model.Orders = db.Bestallning.Where(r => r.Levererad == false)
.OrderByDescending(r => r)
.ToList();
foreach (var order in model.Orders)
{
var customer = new Kund();
order.Kund = db.Kund.FirstOrDefault(r => r.KundId == order.KundId);
}
}
return(model);
}
public async Task <IdentityResult> UpdateUserIdentity(Kund model, UserManager <IdentityUser> userManager, SignInManager <IdentityUser> signInManager, HttpRequest request, HttpResponse response, System.Security.Claims.ClaimsPrincipal user)
{
var identityuser = await userManager.GetUserAsync(user);
identityuser.UserName = model.AnvandarNamn;
await userManager.UpdateNormalizedUserNameAsync(identityuser);
var customer = Services.AccountService.Instance.GetInloggedCustomerInfo(request);
var result = await userManager.ChangePasswordAsync(identityuser, customer.Losenord, model.Losenord);
if (result.Succeeded)
{
await signInManager.RefreshSignInAsync(identityuser);
Services.AccountService.Instance.UpdateUser(model, request);
return(result);
}
return(result);
}
public void SaveCustomer(Kund customer)
{
if (customer.KundId == 0)
{
// Add new product
_context.Kund.Add(customer);
}
else
{
// Edit existing product
var p = Customers.FirstOrDefault(x => x.KundId == customer.KundId);
if (p != null)
{
_context.Entry(p).CurrentValues.SetValues(customer);
}
}
_context.SaveChanges();
}
public async Task <IActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var customer = new Kund()
{
Namn = model.Kund.Namn,
Gatuadress = model.Kund.Gatuadress,
Postnr = model.Kund.Postnr,
Postort = model.Kund.Postort,
Telefon = model.Kund.Telefon,
Email = model.Kund.Email,
AnvandarNamn = "XYZ",
Losenord = "XYZ",
Bonuspoang = 0
};
_context.Kunds.Add(customer);
_context.SaveChanges();
var user = new ApplicationUser {
UserName = model.UserName, KundId = customer.KundId
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, "RegularUser");
await _signInManager.SignInAsync(user, isPersistent : false);
return(RedirectToAction("Index", "Home"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(model));
}
public async Task <IActionResult> Login(Kund user)
{
ApplicationUser loginUser = new ApplicationUser()
{
UserName = user.AnvandarNamn
};
var result = await _signinmanager.PasswordSignInAsync(user.AnvandarNamn, user.Losenord, false, true);
if (result.Succeeded)
{
return(RedirectToAction("LoggedIn", "Account", new { model = user }));
}
else
{
ViewBag.Message = "Felaktig inloggning";
return(View());
}
}
// en metod för att ta bort data, tar bort en kund
public void TaBortEnKund(int Kund_id)
{
try
{
using (var context = new CykelAffärContext())
{
var tabort = new Kund(Kund_id);
context.Kunder.Remove(tabort);
context.SaveChanges();
}
}
catch
{
Console.WriteLine("Du har valt ett id som inte finns, vänligen försök igen!");
Console.WriteLine("");
}
}
public ActionResult Register(Kund model)
{
var validUsername = AccountService.Instance.CheckUserNameIsValid(model, Request);
if (ModelState.IsValid && validUsername == true)
{
var result = RoleAdminService.Instance.Identity("create", new LoginViewModel(), model, userManager, signInManager, Request, Response, User, roleManager);
if (result == true)
{
return(RedirectToAction("Index", "Home"));
}
return(View("Register", model));
}
else if (ModelState.IsValid && validUsername == false)
{
ViewBag.Data = "Användarnamn Upptaget";
return(View(model));
}
return(View(model));
}
public void UpdateKund(Kund kund)
{
using (var conn = CreateConnection())
{
try
{
//Skapar ett SQl objekt som används för att exekvera en lagrade procedur.
var cmd = new SqlCommand("appSchema.usp_UpdateKund", conn);
cmd.CommandType = CommandType.StoredProcedure;
//Lägger till de parametrar som krävs.
cmd.Parameters.Add("@KundID", SqlDbType.Int, 4).Value = kund.KundID;
cmd.Parameters.Add("@Namn", SqlDbType.VarChar, 30).Value = kund.Namn;
cmd.Parameters.Add("@Address", SqlDbType.VarChar, 20).Value = kund.Address;
cmd.Parameters.Add("@Telefonnummer", SqlDbType.VarChar, 16).Value = kund.Telefonnummer;
cmd.Parameters.Add("@Mail", SqlDbType.VarChar, 50).Value = kund.E_Mail;
cmd.Parameters.Add("@MedlemskapID", SqlDbType.Int, 4).Value = kund.MedlemskapID;
//Öppnar anslutningen.
conn.Open();
//Exekverar den lagrade proceduren. Vi kan använda denna metoden då inga poster returneras.
cmd.ExecuteNonQuery();
}
catch
{
throw new ApplicationException("Error in KundDAL UpdateKund");
}
}
}
// lägg till ny kund
public void InsertKund(Kund kund)
{
using (var con = CS())
{
try
{
var cmd = new SqlCommand("AppSchema.usp_addKund", con);
cmd.CommandType = CommandType.StoredProcedure;
// kundparametrarna
cmd.Parameters.Add("@Fnamn", SqlDbType.VarChar, 30).Value = kund.Fnamn;
cmd.Parameters.Add("@Enamn", SqlDbType.VarChar, 30).Value = kund.Enamn;
cmd.Parameters.Add("@Adress", SqlDbType.VarChar, 40).Value = kund.Adress;
cmd.Parameters.Add("@Postnr", SqlDbType.VarChar, 5).Value = kund.Postnr;
cmd.Parameters.Add("@Ort", SqlDbType.VarChar, 30).Value = kund.Ort;
cmd.Parameters.Add("@Kundid", SqlDbType.Int, 4).Direction = ParameterDirection.Output;
con.Open();
cmd.ExecuteNonQuery(); // exekverar sql-statementet
kund.Kundid = (int)cmd.Parameters["@Kundid"].Value;
}
catch
{
throw new ApplicationException("Det blev något fel vid tillägg av ny kund");
}
}
}
// uppdatera kund, annan lagrad procedur än insert och ingen outparameter
public void UpdateKund(Kund kund)
{
using (var con = CS())
{
try
{
var cmd = new SqlCommand("AppSchema.usp_UpdateKund", con);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("@Kundid", SqlDbType.Int, 4).Value = kund.Kundid;
cmd.Parameters.Add("@Fnamn", SqlDbType.VarChar, 30).Value = kund.Fnamn;
cmd.Parameters.Add("@Enamn", SqlDbType.VarChar, 30).Value = kund.Enamn;
cmd.Parameters.Add("@Adress", SqlDbType.VarChar, 40).Value = kund.Adress;
cmd.Parameters.Add("@Postnr", SqlDbType.VarChar, 5).Value = kund.Postnr;
cmd.Parameters.Add("@Ort", SqlDbType.VarChar, 30).Value = kund.Ort;
con.Open();
cmd.ExecuteNonQuery();
}
catch
{
throw new ApplicationException("Det blev något fel vid uppdatering av ny kund");
}
}
}
