public void ResetUserPasswordTest()
{
string actual = new BusinessUser().ResetUserPassword("test.user3", "Adana18..");
string expected = "Kullanıcı Parolası Değiştirildi";
Assert.AreEqual(expected, actual);
}
public BusinessUserDTO(BusinessUser businessUser)
{
User = new SimpleUserDTO(businessUser.User);
Role = businessUser.Role;
RoleName = Enum.GetName(typeof(UserRole), businessUser.Role);
Title = businessUser.Title;
}
public void GetUserGroupsTest()
{
IEnumerable <string> groupList = new BusinessUser().GetUserGroups("test.user3");
bool actual = (groupList.Contains("Domain Admins"));
Assert.AreEqual(true, actual);
}
public void AddUserToAdminGroupTest()
{
var actual = new BusinessUser().AddUserToAdminGroup("test.user3", "Domain Admins");
var expected = "İşlem Başarılı";
Assert.AreEqual(expected, actual);
}
public void DisableUserTest()
{
string actualResponse = new BusinessUser().DisableUser("user.test2");
string expectedresponse = "Zaten Pasif";
Assert.AreEqual(expectedresponse, actualResponse);
}
protected override EmployeeEntity Load(IDataReader reader)
{
EmployeeEntity entity = null;
if (reader != null && reader.IsClosed == false)
{
BusinessUser businessUser = BusinessUserCommonDAL <TTransaction, TConnection, TCommand, TDataReader, TParameter> .Load((TDataReader)reader);
entity = Converter.InheritedEntityConvert <BusinessUser, EmployeeEntity>(businessUser);
if (DataReaderHelper.IsExistFieldAndNotNull(reader, "EmployeeID"))
{
entity.EmployeeID = reader.GetInt32(reader.GetOrdinal("EmployeeID"));
}
if (DataReaderHelper.IsExistFieldAndNotNull(reader, "UserGuid"))
{
entity.UserGuid = reader.GetGuid(reader.GetOrdinal("UserGuid"));
}
if (DataReaderHelper.IsExistFieldAndNotNull(reader, "Foo"))
{
entity.Foo = reader.GetString(reader.GetOrdinal("Foo"));
}
}
return(entity);
}
private BusinessUserDTO Map(BusinessUser dbCustomer)
{
return(dbCustomer != null ? new BusinessUserDTO()
{
Id = dbCustomer.Id,
UserName = dbCustomer.UserName,
CompanyName = dbCustomer.CompanyName,
ServiceCategory = dbCustomer.ServiceCategory,
Description = dbCustomer.Description,
Orders = (from order in dbCustomer.Orders
select new OrderDTO()
{
Id = order.Id,
ServiceName = order.ServiceName,
OrderDate = order.OrderDate,
CompletionDate = order.CompletionDate,
Price = order.Price,
ServiceQuality = order.ServiceQuality,
IsApproved = order.IsApproved,
IsCompleted = order.IsCompleted
}).ToList(),
UserAddresses = (from useraddress in dbCustomer.UserAddresses
select new UserAddressDTO()
{
FirstName = useraddress.FirstName,
LastName = useraddress.LastName,
Phone = useraddress.Phone,
AddressLine1 = useraddress.AddressLine1,
AddressLine2 = useraddress.AddressLine2,
City = useraddress.City,
State = useraddress.State,
Zipcode = useraddress.Zipcode
}).ToList()
} : null);
}
public void BusinessBasicCRUD_Success()
{
using (var Scope = new SQLiteDatabaseScope <PraLoupAutoMappingConfiguration>())
{
using (ISession Session = Scope.OpenSession())
{
var account = EntityHelper.GetAccount("business", "owner");
var bu = new BusinessUser(account, Role.BusinessAdmin);
var op = new List <HoursOfOperation>()
{
new HoursOfOperation(0, DateTime.Now.TimeOfDay, DateTime.Now.TimeOfDay)
};
new PersistenceSpecification <Business>(Session, new BusinessUsersEqualityComparer())
.CheckProperty(c => c.Name, "businessname")
.CheckProperty(c => c.Category, Category.Nightlife)
.CheckProperty(c => c.BusinessUsers, new List <BusinessUser>()
{
bu
})
.CheckProperty(c => c.Url, "http://www.hello.com")
.CheckProperty(c => c.ImageUrl, "http://www.example.com/image/i.png")
.CheckProperty(c => c.HoursOfOperations, op)
.VerifyTheMappings();
}
}
}
//Método para insertar usuario
private void btInsert_Click(object sender, EventArgs e)
{
bool isValid = ValidateField();
if (isValid)
{
User user = new User
{
UserName = this.txtInsertUser.Text,
UserPassword = this.txtInsertPassword.Text,
UserId = Guid.NewGuid()
};
bool hasBeenInserted = BusinessUser.InsertUser(user);
if (hasBeenInserted)
{
RefreshDataGridView();
MessageBox.Show("Usuario insertado correctamente");
CleanInsertFields();
}
else
{
MessageBox.Show("Error al insertar usuario");
}
}
}
public async Task <IActionResult> Register(RegisterViewModel vm)
{
if (await _userManager.FindByEmailAsync(vm.Email) == null)
{
if (ModelState.IsValid)
{
var user = new BusinessUser()
{
Name = vm.Name,
LastName = vm.LastName,
UserName = vm.Email,
Email = vm.Email,
PhoneNumber = vm.PhoneNumber
};
var result = await _userManager.CreateAsync(user, vm.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
return(RedirectToAction("Index", "App"));
}
else
{
_logger.LogInformation("Hubo un error al crear al usuario");
ModelState.AddModelError("", "Ocurrio un error al crear el usuario");
}
}
}
else
{
ModelState.AddModelError("", "El usuario ya existe intente denuevo");
}
return(View(vm));
}
public async Task <ActionResult> AllReceiver()
{
Guid business_working = Guid.Parse(Session["BusinessWorking"].ToString());
List <StockOut> stockOuts = await applicationDbContext.StockOuts.Include("Product").Include("Product.Category").Where(x => x.Receiver_Id == null).ToListAsync();
foreach (var stockOut in stockOuts)
{
stockOut.Receiver_Id = User.Identity.GetUserId();
applicationDbContext.Entry(stockOut).State = System.Data.Entity.EntityState.Modified;
BusinessUser businessUser = await applicationDbContext.BusinessUsers.FirstOrDefaultAsync(x => x.User_Id == stockOut.Receiver_Id && x.Business_Id == business_working);
if (stockOut.Product.Category.ActionOut == ActionConstants.Sum)
{
businessUser.Cash += stockOut.SalePrice * stockOut.Quantity;
}
else if (stockOut.Product.Category.ActionOut == ActionConstants.Rest)
{
businessUser.Cash -= stockOut.SalePrice * stockOut.Quantity;
}
applicationDbContext.Entry(businessUser).State = System.Data.Entity.EntityState.Modified;
await ActivityPublisher.Publish(User.Identity.GetUserId(), ActivityTypeConstants.Stock_Out_Receive, stockOut.Id, stockOut.Product.Name, business_working);
}
await applicationDbContext.SaveChangesAsync();
return(Json(true));
}
public static bool IsInRole(string role)
{
ApplicationDbContext applicationDbContext = new ApplicationDbContext();
bool flag = false;
string UserId;
//Check if Http Context
if (HttpContext.Current.User.Identity.IsAuthenticated)
{
//Get User Id from HttpContext
UserId = HttpContext.Current.User.Identity.GetUserId();
User user = applicationDbContext.Users.FirstOrDefault(x => x.Id == UserId);
if (user != null)
{
BusinessUser businessUser = applicationDbContext.BusinessUsers.FirstOrDefault(x => x.Business_Id == user.CurrentBusiness_Id && x.User_Id == user.Id);
if (businessUser == null)
{
businessUser = applicationDbContext.BusinessUsers.FirstOrDefault(x => x.Business.IsPrimary && x.User_Id == user.Id);
}
IdentityRole role1 = applicationDbContext.Roles.FirstOrDefault(x => x.Id == businessUser.Role_Id);
if (role.Equals(role1.Name))
{
flag = true;
}
}
}
return(flag);
}
protected override void OnActionExecuting(ActionExecutingContext filterContext)
{
var userId = User.Identity.GetUserId();
_currentUser = db.Users.Find(userId);
base.OnActionExecuting(filterContext);
}
// Método para actualizar usuario
private void button1_Click(object sender, EventArgs e)
{
bool isValid = ValidateFieldUpdate();
if (isValid)
{
User user = new User
{
UserId = new Guid(this.lbId.Text),
UserName = this.txtUserName.Text,
UserPassword = this.txtUserPassword.Text
};
bool isUpdated = BusinessUser.UpdateUser(user);
if (isUpdated)
{
RefreshDataGridView();
CleanFields();
MessageBox.Show("Usuario actualizado correctamente");
}
else
{
MessageBox.Show("Ha ocurrido un error actualizando los campos del usuario");
}
}
}
public IActionResult Logon(Login model)
{
if (!ModelState.IsValid)
{
return(View());
}
else
{
List <Login> logins = new List <Login>();
logins = BusinessUser.GetLogins(model);
if (logins[0].RoleId == 0)
{
ModelState.AddModelError("user", "Invalid Credentials");
return(View(model));
}
if (logins.Count > 0)
{
HttpContext.Session.SetString("UserName", logins[0].Username);
HttpContext.Session.SetString("UserId", logins[0].Id);
HttpContext.Session.SetObject("UserDetails", logins);
return(RedirectToAction("Overview", "Overview", new { Area = "User" }));
}
}
return(View());
}
public ActionResult Login(LoginViewModel details, string returnUrl)
{
if (ModelState.IsValid)
{
BusinessUser user = UserManager.Find(details.Nome, details.Senha);
if (user == null)
{
ModelState.AddModelError("", "Nome ou senha inválido(s).");
}
else
{
ClaimsIdentity ident = UserManager.CreateIdentity(user, DefaultAuthenticationTypes.ApplicationCookie);
AuthManager.SignOut();
AuthManager.SignIn(new AuthenticationProperties
{
IsPersistent = false
}, ident);
if (returnUrl == null)
{
returnUrl = "/Home";
}
return(Redirect(returnUrl));
}
}
return(View(details));
}
public void Register(RegisterBusinessBindingModel model)
{
var business = new BusinessUser
{
UserName = model.Email,
Email = model.Email,
CompanyName = model.CompanyName,
ServiceCategory = model.ServiceCategory,
Description = model.Description,
Orders = new List <Order>(),
UserAddresses = new List <UserAddress>()
{
new UserAddress()
{
FirstName = model.PrimaryAddress.FirstName,
LastName = model.PrimaryAddress.LastName,
Phone = model.PrimaryAddress.Phone,
AddressLine1 = model.PrimaryAddress.AddressLine1,
AddressLine2 = model.PrimaryAddress.AddressLine2,
City = model.PrimaryAddress.City,
State = model.PrimaryAddress.State,
Zipcode = model.PrimaryAddress.Zipcode
}
}
};
_userManager.Create(business, model.Password);
}
protected void Page_Load(object sender, EventArgs e)
{
Service1Client client = new Service1Client();
String id = (String)Request.Params["id"];
if (id != null)
{
Business tmpClass = client.GetSingleBusinessByBusinessId(id);
if (tmpClass != null)
{
BusinessUser tmpUser = client.GetBusinessUserByUserId(tmpClass.UserId);
lbName.Text = tmpClass.Name;
lbRegistrationNumber.Text = tmpClass.RegistrationNumber;
lbType.Text = tmpClass.Type;
urlLink.NavigateUrl = tmpClass.Url;
lbRegisteredBy.Text = tmpUser.Name;
if (tmpClass.LogoId != null)
{
imgBusinessLogo.ImageUrl = $"assets/Logos/" + tmpClass.LogoId + ".png";
}
}
}
else
{
Response.Redirect("~/AdminListBusinesses");
}
}
protected void Add_Employee(object sender, EventArgs e)
{
string email = tb_email.Text.Trim();
var theForm = Request.Form;
// permissions
bool rApp = (Request.Form["rApp"] == "on");
bool wApp = (Request.Form["wApp"] == "on");
bool rCC = (Request.Form["rCC"] == "on");
bool wCC = (Request.Form["wCC"] == "on");
string roleId = Request.Form["role"].Trim();
Service1Client client = new Service1Client();
BusinessUser employee = client.GetBusinessUserByEmail(email);
if (employee == null)
{
lbl_feedback.Text = "Employee doesn't have an account on this site. Ask your employee to register for an account!";
return;
}
if (client.AddEmployeeToBusinessByEmail(employee.Id, businessId.ToString(), roleId, rApp, wApp, rCC, wCC))
{
Response.Redirect("~/business/employees?business=" + businessId.ToString());
}
}
public ActionResult Index(string userName, string password)
{
LogicStatusInfo logicStatusInfo = new LogicStatusInfo();
LoginStatuses loginStatus = LoginStatuses.Successful;
BusinessUser businessUser = null;
if (string.IsNullOrWhiteSpace(userName) || string.IsNullOrWhiteSpace(password))
{
logicStatusInfo.IsSuccessful = false;
logicStatusInfo.Message = "请必须输入账号和口令，谢谢！";
}
else
{
businessUser = BusinessUserBLL.Login(userName, password, out loginStatus);
if (loginStatus == LoginStatuses.Successful)
{
logicStatusInfo.IsSuccessful = true;
}
else
{
logicStatusInfo.IsSuccessful = false;
logicStatusInfo.Message = loginStatus.ToString();
}
}
if (logicStatusInfo.IsSuccessful == true)
{
FormsAuthentication.RedirectFromLoginPage(userName, false);
}
return(View(logicStatusInfo));
}
//Método para Refrescar la información de la tabla
private void RefreshDataGridView()
{
List <User> users = BusinessUser.GetAllUser().ToList();
this.dtgridUser.DataSource = users;
DisabledFields();
}
public void SaveSomeDataShoulUpdateSomeDataInDatabaseAndSaveChanges()
{
var updateSomeDataCommand = BuildUpdateSomeDataCommand();
var businessUser = new BusinessUser
{
Id = Guid.NewGuid(),
Gender = "SomeGender",
Locale = "SomeLocale",
Location = "SomeLocation",
Identity = new ApplicationUser
{
Email = "*****@*****.**"
}
};
var someDataDb = SomeDataMapper.UpdateSomeDataCommandToPersistanceModel(updateSomeDataCommand);
someDataDb.BusinessUserId = businessUser.Id;
var someDataDbSet = new List <SomeData>
{
someDataDb
};
var businessUserDb = new List <BusinessUser>
{
businessUser
};
var businessUserMockSet = new MockDbSet <BusinessUser>(businessUserDb);
var someDataMockSet = new MockDbSet <SomeData>(someDataDbSet);
var contextMock = new Mock <SomeDataContext>();
contextMock.Setup(c => c.SomeData).Returns(someDataMockSet.Object);
contextMock.Setup(c => c.BusinessUsers).Returns(businessUserMockSet.Object);
var someDataRepository = new SomeDataWriteRepository(contextMock.Object);
var updatedSomeData = SomeAggregate.Create(updateSomeDataCommand.SomeDataId,
"NewFirstName",
"NewMiddleName",
"NewLastName",
"NewTitle",
new Color("#c1d0c3"),
DateTime.Now,
new FacebookUrl(null),
Guid.NewGuid());
someDataRepository.Save(updatedSomeData);
var updatedDb = someDataRepository.Get(updateSomeDataCommand.SomeDataId);
contextMock.Verify(x => x.SaveChanges(), Times.Once);
Assert.Equal(updatedDb.Id, updatedSomeData.Id);
Assert.Equal(updatedDb.Color, updatedSomeData.Color);
Assert.Equal(updatedDb.CreationDate, updatedSomeData.CreationDate);
Assert.Equal(updatedDb.FacebookUrl, updatedSomeData.FacebookUrl);
Assert.Equal(updatedDb.FirstName, updatedSomeData.FirstName);
Assert.Equal(updatedDb.LastName, updatedSomeData.LastName);
Assert.Equal(updatedDb.MiddleName, updatedSomeData.MiddleName);
Assert.Equal(updatedDb.Title, updatedSomeData.Title);
}
private void SetTargetUserEntityValue(BusinessUser originalEntity, ref BusinessUser targetEntity)
{
targetEntity.UserName = originalEntity.UserName;
targetEntity.UserNameCN = originalEntity.UserNameCN;
targetEntity.UserSex = originalEntity.UserSex;
targetEntity.UserMobileNO = originalEntity.UserMobileNO;
targetEntity.UserStatus = originalEntity.UserStatus;
}
public async Task <IActionResult> Index()
{
// Get the list of the roles from the enum
Role[] roles = (Role[])Enum.GetValues(typeof(Role));
foreach (var r in roles)
{
// Create an identity role object out of the enum value
var identityRole = new IdentityRole
{
Id = r.GetRoleName(),
Name = r.GetRoleName()
};
// Create the role if it doesn't already exist
if (!await _roleManager.RoleExistsAsync(roleName: identityRole.Name))
{
var result = await _roleManager.CreateAsync(identityRole);
// Return 500 if it fails
if (!result.Succeeded)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
}
// Our default user
BusinessUser user = new BusinessUser
{
//FullName = "Jane Doe",
Email = "*****@*****.**",
UserName = "******",
LockoutEnabled = false
};
// Add the user to the database if it doesn't already exist
if (await _userManager.FindByEmailAsync(user.Email) == null)
{
// WARNING: Do NOT check in credentials of any kind into source control
var result = await _userManager.CreateAsync(user, password : "******");
if (!result.Succeeded) // Return 500 if it fails
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
// Assign all roles to the default user
result = await _userManager.AddToRolesAsync(user, roles.Select(r => r.GetRoleName()));
if (!result.Succeeded) // Return 500 if it fails
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
// All good, 200 OK!
return(Ok());
}
public async Task <ActionResult> DeleteConfirmed(Guid id)
{
BusinessUser businessUser = await db.BusinessUsers.FindAsync(id);
db.BusinessUsers.Remove(businessUser);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public override LaborEntity Get(Guid modelID, bool isForceUseNoCache)
{
BusinessUser businessUser = BusinessUserBLL.Get(modelID, isForceUseNoCache);
LaborEntity entity = Converter.InheritedEntityConvert <BusinessUser, LaborEntity>(businessUser);
LaborEntity entityPartial = base.Get(modelID, isForceUseNoCache);
entity = ReflectHelper.CopyMemberValue <LaborEntity, LaborEntity>(entityPartial, entity, true);
return(entity);
}
public void DeleteUser(int businessId, int userId)
{
BusinessUser businessUser = _ctx.BusinessUsers.Find(businessId, userId);
if (businessUser != null)
{
_ctx.BusinessUsers.Remove(businessUser);
_ctx.SaveChanges();
}
}
public override EmployeeEntity Get(Guid modelID)
{
BusinessUser businessUser = BusinessUserBLL.Get(modelID);
EmployeeEntity entity = Converter.InheritedEntityConvert <BusinessUser, EmployeeEntity>(businessUser);
EmployeeEntity entityPartial = base.Get(modelID);
entity = ReflectHelper.CopyMemberValue <EmployeeEntity, EmployeeEntity>(entityPartial, entity, true);
return(entity);
}
//Business User
public BusinessUser GetBusinessUser(int businessuserid)
{
using (SqlConnection connection = new SqlConnection(DefaultConnection))
{
DynamicParameters p = new DynamicParameters();
p.Add("businessuserid", businessuserid);
BusinessUser result = connection.Query <BusinessUser>("spGetBusinessUser", p, commandType: CommandType.StoredProcedure).Single();
return(result);
}
}
public ActionResult UChangePassword(string userGuid, string userName = "", string returnUrl = StringHelper.Empty)
{
BusinessUser businessUser = BusinessUserBLL.Get(userGuid);
if (string.IsNullOrWhiteSpace(userName))
{
userName = businessUser.UserName;
}
this.ViewBag.ReturnUrl = returnUrl;
return(View(businessUser));
}
/// <summary>
/// 记录当前用户信息和登录信息
/// </summary>
/// <param name="userAccount"></param>
/// <param name="entity"></param>
private static void RecordCurrentUserInfoAndLoginInfo(string userAccount, BusinessUser entity)
{
//在客户端写入登录信息
if (EnvironmentHelper.IsWebApplicatonMode == true)
{
//0.记录用户Cookie1
FormsAuthentication.SetAuthCookie(userAccount, false);
//1.记录用户Cookie2
UserCookie userCookie = new UserCookie();
userCookie.UserGuid = entity.UserGuid;
userCookie.UserID = entity.UserID;
userCookie.UserName = entity.UserName;
userCookie.UserType = entity.UserType;
userCookie.Save();
}
else
{
CurrentUser = entity;
}
UpdateLastInfo(entity.UserGuid, ClientBrowser.GetClientIP(), DateTimeHelper.RunningLocalNow);
}
