public static int UpdateSqlUser(SqlUser item)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// load original meta item
SqlUser origItem = (SqlUser)PackageController.GetPackageItem(item.Id);
if (origItem == null)
{
return(BusinessErrorCodes.ERROR_MSSQL_USERS_PACKAGE_ITEM_NOT_FOUND);
}
// check package
int packageCheck = SecurityContext.CheckPackage(origItem.PackageId, DemandPackage.IsActive);
if (packageCheck < 0)
{
return(packageCheck);
}
// place log record
TaskManager.StartTask("SQL_USER", "UPDATE", origItem.Name);
TaskManager.ItemId = item.Id;
try
{
// get service
DatabaseServer sql = GetDatabaseServer(origItem.ServiceId);
// update service item
sql.UpdateUser(item, GetSqlDatabasesArray(origItem.PackageId, origItem.GroupName));
// update meta item
if (item.Password == "")
{
item.Password = CryptoUtils.Decrypt(origItem.Password);
}
item.Password = CryptoUtils.Encrypt(item.Password);
PackageController.UpdatePackageItem(item);
return(0);
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
// Return a generic error instead of re-throwing an exception
return(BusinessErrorCodes.FAILED_EXECUTE_SERVICE_OPERATION);
}
finally
{
TaskManager.CompleteTask();
}
}
/// <summary>
/// Checks if the User Email is available for registration.
/// </summary>
/// <param name="email">User Email to be checked</param>
/// <param name="userId"></param>
/// <returns>
/// Returns true if User Email is available, else false.
/// </returns>
public static ResponseOutput CheckUserEmailAvailability(string email, int userId = 0)
{
SqlUser sqlUser = new SqlUser();
ResponseOutput responseOutput = new ResponseOutput();
responseOutput.IsSuccessful = false;
if (!string.IsNullOrWhiteSpace(email))
{
bool ret = sqlUser.CheckUserEmailAvailability(email, userId);
if (ret)
{
responseOutput.IsSuccessful = true;
responseOutput.OutputMessage = string.Empty;
}
else
{
responseOutput.IsSuccessful = false;
responseOutput.OutputMessage = "Entered email Id already used, please use another email Id.";
}
}
else
{
responseOutput.IsSuccessful = false;
responseOutput.OutputMessage = "Please enter email Id.";
}
return responseOutput;
}
public async Task HandleAction_CannotCreateJob_ReturnsFalse()
{
// Arrange
_jobsRepositoryMock.Setup(t => t.AddJobMessage(JobType.GenerateUserStories,
false,
It.IsAny <string>(),
null,
It.IsAny <int?>(),
It.IsAny <string>(),
It.IsAny <int>(),
It.IsAny <string>(),
It.IsAny <string>())).ReturnsAsync((int?)null);
_generateActionsRepositoryMock.Setup(m => m.IsProjectMaxArtifactBoundaryReached(It.IsAny <int>())).ReturnsAsync(false);
var sqlUser = new SqlUser
{
UserId = 123,
Login = "******"
};
_generateActionsRepositoryMock.Setup(m => m.GetUser(It.IsAny <int>())).ReturnsAsync(sqlUser);
_generateActionsRepositoryMock.Setup(t => t.JobsRepository).Returns(_jobsRepositoryMock.Object);
// Act
var result = await _actionHelper.HandleAction(_tenantInformation, _message, _generateActionsRepositoryMock.Object);
// Assert
Assert.IsFalse(result, "Should return false if job creation fails.");
_jobsRepositoryMock.Verify(m => m.AddJobMessage(JobType.GenerateUserStories, It.IsAny <bool>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <int?>(), It.IsAny <string>(), It.IsAny <int>(), It.IsAny <string>(), It.IsAny <string>()), Times.Once);
}
/// <summary>Creates a new user.</summary>
/// <param name="user">The user.</param>
/// <returns>The created user.</returns>
public async Task <IUser> Create(IUser user)
{
using (var connection = await this.OpenConnection())
{
var k = new SqlUser(user);
using (var transaction = connection.BeginTransaction())
{
try
{
k.Created = DateTimeOffset.UtcNow;
var id = connection.ExecuteScalar <long>(
"INSERT INTO Users (UserId, Password, FirstName, LastName, Enabled, Created) VALUES (@UserId, @Password, @FirstName, @LastName, @Enabled, @Created); SELECT SCOPE_IDENTITY()",
new { k.UserId, k.Password, k.FirstName, k.LastName, k.Enabled, Created = k.Created.ToString("s") },
transaction);
transaction.Commit();
var result = await connection.QueryAsync <SqlUser>("SELECT * FROM Users WHERE Id = @Id", new { Id = id });
return(result.FirstOrDefault());
}
catch (Exception)
{
transaction.Rollback();
throw;
}
}
}
}
public void ImportItem(int packageId, int itemTypeId,
Type itemType, ResourceGroupInfo group, string itemName)
{
// get service id
int serviceId = PackageController.GetPackageServiceId(packageId, group.GroupName);
if (serviceId == 0)
{
return;
}
if (itemType == typeof(SqlDatabase))
{
// import database
SqlDatabase db = new SqlDatabase();
db.ServiceId = serviceId;
db.PackageId = packageId;
db.Name = itemName;
db.GroupName = group.GroupName;
PackageController.AddPackageItem(db);
}
else if (itemType == typeof(SqlUser))
{
// import user
SqlUser user = new SqlUser();
user.ServiceId = serviceId;
user.PackageId = packageId;
user.Name = itemName;
user.GroupName = group.GroupName;
user.Password = "";
PackageController.AddPackageItem(user);
}
}
public ActionResult Profile()
{
Customer customer = SqlUser.GetCustomer(SqlUser.GetUser(User.Identity.Name));
//Console.WriteLine(customer.CompanyName);
ViewBag.user = SqlUser.GetUser(User.Identity.Name);
return View(customer);
}
public ActionResult Delete(DateTime from, DateTime to, int idCourt, FormCollection collection)
{
try
{
Advertisement ad = SqlAdvertisement.GetAdvertisement(from, to, idCourt);
User user = SqlUser.GetUser(User.Identity.Name);
if (user.RoleID == 1)
{
SqlAdvertisement.DeleteAdvertisement(ad, user.UserID);
}
else
{
if (ad.Payment == 0)
{
SqlAdvertisement.DeleteAdvertisement(ad, user.UserID);
}
else
{
return(RedirectToAction("ErrorDelete"));
}
}
if (user.RoleID == 1)
{
return(RedirectToAction("Index"));
}
else
{
return(RedirectToAction("AdsForUsers"));
}
}
catch
{
return(View());
}
}
public ActionResult ChangePassword(string oldPassword, string newPassword, string repeatPassword)
{
string password = null;
User tmp = SqlUser.GetUser(User.Identity.Name);
password = SqlUser.GetUserPassword(tmp);
if (Crypto.Hash(oldPassword) != password)
{
ViewBag.Message = "Stare hasło nie jest prawidłowe! ";
return View();
}
else if(newPassword != repeatPassword)
{
ViewBag.Message = "Hasła nie są takie same! ";
return View();
}
else if (newPassword == repeatPassword)
{
bool status = SqlUser.ChangePassword(Crypto.Hash(oldPassword), Crypto.Hash(newPassword), tmp.Email);
return RedirectToAction("Logout");
}
else
{
ViewBag.Message = "Nie wiem jak to zrobiłeś/aś ale no nie pykło ";
return View();
}
}
public ActionResult AdsForUsers()
{
User user = SqlUser.GetUser(User.Identity.Name);
List <Advertisement> ads = SqlAdvertisement.GetAdvertisements(user.UserID);
return(View(ads));
}
public static string GetUserRole(this HtmlHelper html)
{
string CurrentUserEmail = HttpContext.Current.User.Identity.Name.ToString();
string CurrentUserRole = SqlUser.GetUserRole(CurrentUserEmail);
return(CurrentUserRole);
}
protected void Save_Click(object sender, EventArgs e)
{
SqlServer server = SqlServer.CurrentServer;
server.Connect();
try
{
SqlDatabase database = SqlDatabase.CurrentDatabase(server);
SqlDatabaseRole role = database.DatabaseRoles[Request["Role"]];
foreach (ListItem item in RoleUsers.Items)
{
SqlUser user = database.Users[item.Value];
if (user.IsMember(role.Name) && !item.Selected)
{
role.DropMember(user.Name);
}
else if (!user.IsMember(role.Name) && item.Selected)
{
role.AddMember(role.Name);
}
}
}
catch (Exception ex)
{
ErrorMessage.Text = ex.Message;
return;
}
finally
{
server.Disconnect();
}
Response.Redirect("DatabaseRoles.aspx?database=" + Request["database"]);
}
public ActionResult Create([Bind(Include = "Name, DateFrom,DateTo, CourtID")] Advertisement ad)
{
try
{
if (ModelState.IsValid)
{
User user = SqlUser.GetUser(User.Identity.Name);
ad.Payment = 0;
ad.UserID = user.UserID;
SqlAdvertisement.AddModifyAdvertisement(ad);
if (user.RoleID == 1)
{
return(RedirectToAction("Index"));
}
else
{
return(RedirectToAction("AdsForUsers"));
}
}
return(RedirectToAction("Index", "Home"));
}
catch
{
return(View(ad));
}
}
public void TestUserNameShouldBeEscaped()
{
var user = new SqlUser("foo.bar", "dbo");
var createScript = user.ScriptCreate();
StringAssert.StartsWith("CREATE USER [foo.bar]", createScript);
}
public void BindItem(SqlUser item)
{
// bind again
BindDatabases(item.PackageId, item.GroupName);
Utils.SelectListItem(ddlDefaultDatabase, item.DefaultDatabase);
}
private void initPline()
{
//初始化新增模版里程序下拉列表
string sql = "SELECT PLINE_CODE,PLINE_NAME FROM CODE_PRODUCT_LINE WHERE COMPANY_CODE = '" + theCompanyCode + "'";
SqlUser.SelectCommand = sql;
SqlUser.DataBind();
}
private void initUser()
{
//初始化人员下拉列表
string sql = "SELECT USER_ID,USER_CODE,USER_NAME FROM CODE_USER WHERE COMPANY_CODE = '" + theCompanyCode + "' and user_type='A' ";
SqlUser.SelectCommand = sql;
SqlUser.DataBind();
}
private void initUser()
{
//初始化用户下拉列表
string sql = "SELECT A.USER_ID,A.USER_CODE,A.USER_NAME FROM CODE_USER A WHERE A.COMPANY_CODE = '" + theCompanyCode + "' and user_type='B' ";
SqlUser.SelectCommand = sql;
SqlUser.DataBind();
}
private void initUser()
{
//初始化用户下拉列表
string sql = "SELECT USER_ID,USER_CODE,USER_NAME FROM VW_CODE_USER WHERE COMPANY_CODE = '" + theCompanyCode + "' ORDER BY USER_CODE";
SqlUser.SelectCommand = sql;
SqlUser.DataBind();
}
public ActionResult Edit(DateTime from, DateTime to, int idCourt)
{
User user = SqlUser.GetUser(User.Identity.Name);
Advertisement ad = SqlAdvertisement.GetAdvertisement(from, to, idCourt);
ViewBag.Role = user.RoleID;
return(View(ad));
}
public async Task HandleAction_CreatesJob_ReturnsTrue()
{
// Arrange
var actionHelper = new GenerateDescendantsActionHelper();
_generateActionsRepositoryMock.Setup(t => t.IsProjectMaxArtifactBoundaryReached(ProjectId)).ReturnsAsync(false);
_itemTypeRepoMock.Setup(
t => t.GetCustomItemTypeForProvidedStandardItemTypeIdInProject(ProjectId, DesiredArtifactTypeId))
.ReturnsAsync(new SqlItemType
{
ProjectId = ProjectId,
ItemTypeId = DesiredArtifactTypeId,
Name = "Test"
});
var sqlUser = new SqlUser
{
UserId = UserId,
Login = UserName
};
_generateActionsRepositoryMock.Setup(m => m.GetUser(It.IsAny <int>())).ReturnsAsync(sqlUser);
_userRepoMock.Setup(t => t.GetExistingUsersByIdsAsync(It.IsAny <IEnumerable <int> >())).
ReturnsAsync(new List <SqlUser>
{
sqlUser
});
_jobsRepoMock.Setup(t => t.AddJobMessage(JobType.GenerateDescendants,
false,
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <int?>(),
It.IsAny <string>(),
UserId,
UserName,
It.IsAny <string>())).ReturnsAsync(2);
// Act
var result = await actionHelper.HandleAction(new TenantInformation
{
TenantId = Guid.NewGuid().ToString(),
BlueprintConnectionString = "BlueprintConnectionString"
},
new GenerateDescendantsMessage
{
ArtifactId = ArtifactId,
UserId = UserId,
RevisionId = RevisionId,
ProjectId = ProjectId,
DesiredArtifactTypeId = DesiredArtifactTypeId,
UserName = UserName
},
_generateActionsRepositoryMock.Object);
// Assert
Assert.IsTrue(result, "Action should have succeeded");
_jobsRepoMock.Verify(t => t.AddJobMessage(JobType.GenerateDescendants, It.IsAny <bool>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <int?>(), It.IsAny <string>(), It.IsAny <int>(), It.IsAny <string>(), It.IsAny <string>()), Times.Once);
}
/// <summary>
/// Change Password
/// </summary>
/// <param name="currentPassword"></param>
/// <param name="newPassword"></param>
/// <returns></returns>
public static ResponseOutput ChangePassword(string currentPassword, string newPassword)
{
var responseOutput = new ResponseOutput();
responseOutput.IsSuccessful = false;
if (string.IsNullOrWhiteSpace(newPassword))
{
responseOutput.TypeOfException = Enums.ExceptionType.Fault;
responseOutput.OutputMessage = "New password is empty.";
return responseOutput;
}
if (string.IsNullOrWhiteSpace(currentPassword))
{
responseOutput.TypeOfException = Enums.ExceptionType.Fault;
responseOutput.OutputMessage = "Current password is empty.";
return responseOutput;
}
if (UserContext.Current.User.IsAnonymous == true)
{
responseOutput.TypeOfException = Enums.ExceptionType.Fault;
responseOutput.OutputMessage = "User is not logged in.";
return responseOutput;
}
if (!string.IsNullOrWhiteSpace(currentPassword) && !string.IsNullOrWhiteSpace(newPassword) && UserContext.Current.User.IsAnonymous == false)
{
SqlUser sqlUser = new SqlUser();
var userid = UserContext.Current.User.Id;
var user = FindUser(userid);
if (user != null)
{
if (user.Password == currentPassword)
{
bool isChanged = sqlUser.ChangePassword(userid, currentPassword, newPassword);
responseOutput.IsSuccessful = isChanged;
if (!isChanged)
{
responseOutput.TypeOfException = Enums.ExceptionType.Fault;
responseOutput.OutputMessage = "Password has been not changed.";
}
else
{
responseOutput.TypeOfException = Enums.ExceptionType.NoException;
responseOutput.OutputMessage = "Your password has been successfully changed.";
}
}
else
{
responseOutput.TypeOfException = Enums.ExceptionType.Fault;
responseOutput.OutputMessage = "Current Password is not matched.";
}
}
else
{
responseOutput.TypeOfException = Enums.ExceptionType.Fault;
responseOutput.OutputMessage = "User is not exist.";
}
}
return responseOutput;
}
public int BackupItem(string tempFolder, XmlWriter writer, ServiceProviderItem item, ResourceGroupInfo group)
{
if (item is SqlDatabase)
{
// backup database
DatabaseServer sql = GetDatabaseServer(item.ServiceId);
string backupName = String.Format("DatabaseBackup_{0}.zip", item.Id);
string remoteBackupFile = sql.BackupDatabase(item.Name, backupName, true);
// download remote backup
string localBackupPath = Path.Combine(tempFolder, backupName);
byte[] buffer = null;
FileStream stream = new FileStream(localBackupPath, FileMode.Create, FileAccess.Write);
int offset = 0;
long length = 0;
do
{
// read remote content
buffer = sql.GetTempFileBinaryChunk(remoteBackupFile, offset, FILE_BUFFER_LENGTH);
// write remote content
stream.Write(buffer, 0, buffer.Length);
length += buffer.Length;
offset += FILE_BUFFER_LENGTH;
}while (buffer.Length == FILE_BUFFER_LENGTH);
stream.Close();
// add file pointer
BackupController.WriteFileElement(writer, "DatabaseBackup", backupName, length);
// store meta item
SqlDatabase database = sql.GetDatabase(item.Name);
XmlSerializer serializer = new XmlSerializer(typeof(SqlDatabase));
serializer.Serialize(writer, database);
}
else if (item is SqlUser)
{
// backup user
DatabaseServer sql = GetDatabaseServer(item.ServiceId);
SqlUser userItem = item as SqlUser;
// store user info
SqlUser user = sql.GetUser(item.Name, GetSqlDatabasesArray(item.PackageId, item.GroupName));
user.Password = userItem.Password;
XmlSerializer serializer = new XmlSerializer(typeof(SqlUser));
serializer.Serialize(writer, user);
}
return(0);
}
/// <summary>
/// Deletes the user.
/// </summary>
/// <param name="dtUserId">The dt user id.</param>
/// <returns></returns>
public static bool DeleteUser(DataTable dtUserId)
{
if (dtUserId.Rows.Count > 0)
{
SqlUser sqlUser = new SqlUser();
return sqlUser.DeleteUser(dtUserId);
}
return false;
}
public ActionResult Login(UserLogin login, string ReturnUrl = "")
{
bool Status = false;
string message = "";
if (SqlUser.CheckUserExists(login.Email))
{
if (!SqlUser.CheckEmailVeryfied(login))
{
ViewBag.Message = Resources.Texts.VerifyYourEmail;
return View();
}
if (string.Compare(Crypto.Hash(login.Password), SqlUser.GetUserPassword(login)) == 0)
{
int timeout = login.RememberMe ? 525600 : 30; // 525600 min = 1 rok, 30 dni czas zycia cookiem
var ticket = new FormsAuthenticationTicket(login.Email, login.RememberMe, timeout);
string encrypted = FormsAuthentication.Encrypt(ticket);
var cookie = new HttpCookie(FormsAuthentication.FormsCookieName, encrypted)
{
Expires = DateTime.Now.AddMinutes(timeout),
HttpOnly = true
};
Response.Cookies.Add(cookie);
Status = true;
if (Url.IsLocalUrl(ReturnUrl))
{
return Redirect(ReturnUrl);
}
else
{
switch (SqlUser.GetUserRole(login.Email))
{
case "administrator":
return RedirectToAction("Index", "Admin");
//case "worker":
//return RedirectToAction("Profile", "User");
case "user":
return RedirectToAction("Profile", "User");
}
}
}
else
{
message = Resources.Texts.InvalidPassword;
}
}
else
{
message = Resources.Texts.InvalidUser;
}
ViewBag.Message = message;
ViewBag.Status = Status;
return View();
}
protected void Create_Click(object sender, EventArgs e)
{
SqlServer server = SqlServer.CurrentServer;
server.Connect();
SqlDatabase database = SqlDatabase.CurrentDatabase(server);
SqlUser user = database.Users.Add(Logins.SelectedValue, Username.Text.Trim());
server.Disconnect();
Response.Redirect("EditDatabaseUser.aspx?database=" + Request.Params["database"] + "&user=" + Username.Text.Trim());
}
public async Task <User> CheckUser(string email, string password)
{
if (email != null && password != null)
{
SqlAccount sqlAccount = await dbContext.SqlAccounts.Where(x => x.Email.Equals(email)).FirstOrDefaultAsync(x => x.Password.Equals(password));
SqlAssignement sqlAssignement = await dbContext.SqlAssignements.FirstOrDefaultAsync(x => x.SqlAccount.Id == sqlAccount.Id);
SqlUser sqlUser = sqlAssignement.SqlUser;
return(mapper.Map <User>(sqlUser));
}
throw new NullReferenceException();
}
public ActionResult EditProfile(Customer customer)
{
if (ModelState.IsValid)
{
SqlUser.AddModyfyAddress(customer, User.Identity.Name);
}
else
{
return RedirectToAction("EditProfile", "User");
}
return RedirectToAction("Profile", "User");
}
public void UpdateUser(SqlUser user, string[] databases)
{
try
{
Log.WriteStart("'{0}' UpdateUser", ProviderSettings.ProviderName);
DatabaseProvider.UpdateUser(user, databases);
Log.WriteEnd("'{0}' UpdateUser", ProviderSettings.ProviderName);
}
catch (Exception ex)
{
Log.WriteError(String.Format("'{0}' UpdateUser", ProviderSettings.ProviderName), ex);
throw;
}
}
public void CreateUser(SqlUser user, string password)
{
try
{
Log.WriteStart("'{0}' CreateUser", ProviderSettings.ProviderName);
DatabaseProvider.CreateUser(user, password);
Log.WriteEnd("'{0}' CreateUser", ProviderSettings.ProviderName);
}
catch (Exception ex)
{
Log.WriteError(String.Format("'{0}' CreateUser", ProviderSettings.ProviderName), ex);
throw;
}
}
// GET: Advertisement
public ActionResult Index()
{
List <Advertisement> ads = null;
User user = SqlUser.GetUser(User.Identity.Name);
if (user != null)
{
ads = SqlAdvertisement.GetAdvertisements(user.UserID);
return(View(ads));
}
else
{
return(RedirectToAction("Login", "User"));
}
}
