public static UserInfo GetUserByUsernamePassword(string username, string password, string ip)
{
// place log record
TaskManager.StartTask("USER", "GET_BY_USERNAME_PASSWORD", username);
TaskManager.WriteParameter("IP", ip);
try
{
// try to get user from database
UserInfoInternal user = GetUserInternally(username);
// check if the user exists
if (user == null)
{
TaskManager.WriteWarning("Account not found");
return(null);
}
// compare user passwords
if ((CryptoUtils.SHA1(user.Password) == password) || (user.Password == password))
{
return(new UserInfo(user));
}
return(null);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int ChangeUserPassword(string username, string oldPassword, string newPassword, string ip)
{
// place log record
TaskManager.StartTask("USER", "CHANGE_PASSWORD_BY_USERNAME_PASSWORD", username);
TaskManager.WriteParameter("IP", ip);
try
{
UserInfo user = GetUserByUsernamePassword(username, oldPassword, ip);
if (user == null)
{
TaskManager.WriteWarning("Account not found");
return(BusinessErrorCodes.ERROR_USER_NOT_FOUND);
}
// change password
DataProvider.ChangeUserPassword(-1, user.UserId,
CryptoUtils.Encrypt(newPassword));
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int SetupControlPanelAccounts(string passwordA, string passwordB, string ip)
{
try
{
TaskManager.StartTask("SYSTEM", "COMPLETE_SCPA");
//
TaskManager.WriteParameter("Password A", passwordA);
TaskManager.WriteParameter("Password B", passwordB);
TaskManager.WriteParameter("IP Address", ip);
//
var enabledScpaMode = GetSystemSetupMode();
//
if (enabledScpaMode == false)
{
//
TaskManager.WriteWarning("Attempt to execute SCPA procedure for an uknown reason");
//
return(BusinessErrorCodes.FAILED_EXECUTE_SERVICE_OPERATION);
}
// Entering the security context into Supervisor mode
SecurityContext.SetThreadSupervisorPrincipal();
//
var accountA = UserController.GetUserInternally("serveradmin");
var accountB = UserController.GetUserInternally("admin");
//
var resultCodeA = UserController.ChangeUserPassword(accountA.UserId, passwordA);
//
if (resultCodeA < 0)
{
TaskManager.WriteParameter("Result Code A", resultCodeA);
//
return(resultCodeA);
}
//
var resultCodeB = UserController.ChangeUserPassword(accountB.UserId, passwordB);
//
if (resultCodeB < 0)
{
TaskManager.WriteParameter("Result Code B", resultCodeB);
//
return(resultCodeB);
}
// Disable SCPA mode
SetSystemSettings(SystemSettings.SETUP_SETTINGS, SystemSettings.Empty);
// Operation has succeeded
return(0);
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
//
return(BusinessErrorCodes.FAILED_EXECUTE_SERVICE_OPERATION);
}
finally
{
TaskManager.CompleteTask();
}
}
public override void DoWork()
{
BackgroundTask topTask = TaskManager.TopTask;
int daysBeforeNotify;
// check input parameters
if (!int.TryParse((string)topTask.GetParamValue(DaysBeforeNotify), out daysBeforeNotify))
{
TaskManager.WriteWarning("Specify 'Notify before (days)' task parameter");
return;
}
OrganizationController.DeleteAllExpiredTokens();
var owner = UserController.GetUser(topTask.EffectiveUserId);
var packages = PackageController.GetMyPackages(topTask.EffectiveUserId);
foreach (var package in packages)
{
var organizations = ExchangeServerController.GetExchangeOrganizations(package.PackageId, true);
foreach (var organization in organizations)
{
var usersWithExpiredPasswords = OrganizationController.GetOrganizationUsersWithExpiredPassword(organization.Id, daysBeforeNotify);
var generalSettings = OrganizationController.GetOrganizationGeneralSettings(organization.Id);
var logoUrl = generalSettings != null ? generalSettings.OrganizationLogoUrl : string.Empty;
foreach (var user in usersWithExpiredPasswords)
{
user.ItemId = organization.Id;
if (string.IsNullOrEmpty(user.PrimaryEmailAddress))
{
TaskManager.WriteWarning(string.Format("Unable to send email to {0} user (organization: {1}), user primary email address is not set.", user.DisplayName, organization.OrganizationId));
continue;
}
OrganizationController.SendUserExpirationPasswordEmail(owner, user, "Scheduler Password Expiration Notification", user.PrimaryEmailAddress, logoUrl);
}
}
}
}
public override void DoWork()
{
// Input parameters:
// - SERVER_NAME
// - EXECUTABLE_PATH
BackgroundTask topTask = TaskManager.TopTask;
// get input parameters
string serverName = (string)topTask.GetParamValue("SERVER_NAME");
string execPath = (string)topTask.GetParamValue("EXECUTABLE_PATH");
string execParams = (string)topTask.GetParamValue("EXECUTABLE_PARAMS");
if (execParams == null)
{
execParams = "";
}
// check input parameters
if (String.IsNullOrEmpty(serverName))
{
TaskManager.WriteWarning("Specify 'Server Name' task parameter");
return;
}
if (String.IsNullOrEmpty(execPath))
{
TaskManager.WriteWarning("Specify 'Executable Path' task parameter");
return;
}
// find server by name
ServerInfo server = ServerController.GetServerByName(serverName);
if (server == null)
{
TaskManager.WriteWarning(String.Format("Server with the name '{0}' was not found", serverName));
return;
}
// execute system command
WindowsServer winServer = new WindowsServer();
ServiceProviderProxy.ServerInit(winServer, server.ServerId);
TaskManager.Write(winServer.ExecuteSystemCommand(execPath, execParams));
}
private void SendEmail(string from, string to, string bcc, string subject, string body, bool isHtml)
{
// check input parameters
if (String.IsNullOrEmpty(from))
{
TaskManager.WriteWarning("Specify 'Mail From' task parameter");
return;
}
if (String.IsNullOrEmpty(to))
{
TaskManager.WriteWarning("Specify 'Mail To' task parameter");
return;
}
// send mail message
MailHelper.SendMessage(from, to, bcc, subject, body, isHtml);
}
private void SendMailMessage(string url, string message, string content)
{
BackgroundTask topTask = TaskManager.TopTask;
// input parameters
string mailFrom = (string)topTask.GetParamValue("MAIL_FROM");
string mailTo = (string)topTask.GetParamValue("MAIL_TO");
string mailSubject = (string)topTask.GetParamValue("MAIL_SUBJECT");
string mailBody = (string)topTask.GetParamValue("MAIL_BODY");
if (String.IsNullOrEmpty(mailTo))
{
TaskManager.WriteWarning("The e-mail message has not been sent because 'Mail To' is empty.");
}
else
{
if (String.IsNullOrEmpty(mailFrom))
{
mailFrom = "automatic@localhost";
}
if (!String.IsNullOrEmpty(mailSubject))
{
mailSubject = Utils.ReplaceStringVariable(mailSubject, "url", url);
}
if (!String.IsNullOrEmpty(mailBody))
{
mailBody = Utils.ReplaceStringVariable(mailBody, "url", url);
mailBody = Utils.ReplaceStringVariable(mailBody, "message", message);
mailBody = Utils.ReplaceStringVariable(mailBody, "content", content);
}
else
{
mailBody = message;
}
// send mail message
MailHelper.SendMessage(mailFrom, mailTo, mailSubject, mailBody, false);
}
}
public override void DoWork()
{
// Input parameters:
// - MAIL_FROM
// - MAIL_TO
// - MAIL_SUBJECT
// - MAIL_BODY
BackgroundTask topTask = TaskManager.TopTask;
// get input parameters
string mailFrom = (string)topTask.GetParamValue("MAIL_FROM");
string mailTo = (string)topTask.GetParamValue("MAIL_TO");
string mailSubject = (string)topTask.GetParamValue("MAIL_SUBJECT");
string mailBody = (string)topTask.GetParamValue("MAIL_BODY");
// check input parameters
if (String.IsNullOrEmpty(mailFrom))
{
TaskManager.WriteWarning("Specify 'Mail From' task parameter");
return;
}
if (String.IsNullOrEmpty(mailTo))
{
TaskManager.WriteWarning("Specify 'Mail To' task parameter");
return;
}
if (String.IsNullOrEmpty(mailSubject))
{
TaskManager.WriteWarning("Specify 'Mail Subject' task parameter");
return;
}
// send mail message
MailHelper.SendMessage(mailFrom, mailTo, mailSubject, mailBody, false);
}
public override void DoWork()
{
// Input parameters:
// - FOLDER
// - ZIP_FILE
BackgroundTask topTask = TaskManager.TopTask;
// get input parameters
string filesList = (string)topTask.GetParamValue("FOLDER");
string zipFile = (string)topTask.GetParamValue("ZIP_FILE");
// check input parameters
if (String.IsNullOrEmpty(filesList))
{
TaskManager.WriteWarning("Specify 'Files List' task parameter");
return;
}
if (String.IsNullOrEmpty(zipFile))
{
TaskManager.WriteWarning("Specify 'Zip File' task parameter");
return;
}
// substitute parameters
DateTime d = DateTime.Now;
string date = d.ToString("yyyyMMdd");
string time = d.ToString("HHmm");
filesList = Utils.ReplaceStringVariable(filesList, "date", date);
filesList = Utils.ReplaceStringVariable(filesList, "time", time);
zipFile = Utils.ReplaceStringVariable(zipFile, "date", date);
zipFile = Utils.ReplaceStringVariable(zipFile, "time", time);
// zip files and folders
FilesController.ZipFiles(topTask.PackageId, new string[] { filesList }, zipFile);
}
private void ProcessServiceItems(bool changeState, bool enabled,
int serviceId, List <ServiceProviderItem> items)
{
string methodName = changeState ? "ChangeServiceItemsState" : "DeleteServiceItems";
int PACKET_SIZE = 10;
int ATTEMPTS = 3;
TaskManager.Write(String.Format("Start analyze {0} service ({1} items)",
serviceId, items.Count));
try
{
// convert items to SoapObjects by packets of 0
int startItem = 0;
List <SoapServiceProviderItem> objItems = new List <SoapServiceProviderItem>();
for (int i = 0; i < items.Count; i++)
{
// add to the packet
objItems.Add(SoapServiceProviderItem.Wrap(items[i]));
if (((i > 0) && (i % PACKET_SIZE == 0)) ||
i == (items.Count - 1)) // packet is ready
{
if (objItems.Count == 0)
{
continue;
}
int attempt = 0;
bool success = false;
while (attempt < ATTEMPTS)
{
// increment attempt
attempt++;
try
{
// send packet for calculation
// invoke service provider
TaskManager.Write(String.Format("Invoke {0} method ('{1}' - '{2}' items) - {3} attempt",
methodName, items[startItem].Name, items[i].Name, attempt));
ServiceProvider prov = new ServiceProvider();
ServiceProviderProxy.Init(prov, serviceId);
if (changeState)
{
prov.ChangeServiceItemsState(objItems.ToArray(), enabled);
}
else
{
if (items[i] is VirtualMachine)
{
VirtualizationServerController2012.CheckCustomPsScript(VirtualizationServerController2012.PsScriptPoint.before_deletion, (VirtualMachine)items[i]);
}
prov.DeleteServiceItems(objItems.ToArray());
}
// exit from the loop
success = true;
break;
}
catch (Exception ex)
{
TaskManager.WriteWarning(ex.ToString());
}
}
if (!success)
{
throw new Exception("The number of attemtps has been reached. The whole operation aborted.");
}
// reset packet counter
startItem = i + 1;
objItems.Clear();
}
} // end for items
}
catch (Exception ex)
{
// log exception
TaskManager.WriteWarning(ex.ToString());
}
TaskManager.Write(String.Format("End analyze {0} service ({1} items)",
serviceId, items.Count));
}
public override void DoWork()
{
BackgroundTask topTask = TaskManager.TopTask;
// get input parameters
string mailTo = (string)topTask.GetParamValue("MAIL_TO");
int auditLogSeverity = Utils.ParseInt((string)topTask.GetParamValue("AUDIT_LOG_SEVERITY"), -1);
string auditLogSource = (string)topTask.GetParamValue("AUDIT_LOG_SOURCE");
string auditLogTask = (string)topTask.GetParamValue("AUDIT_LOG_TASK");
string auditLogDate = (string)topTask.GetParamValue("AUDIT_LOG_DATE");
int showExecutionLog = Utils.ParseInt((string)topTask.GetParamValue("SHOW_EXECUTION_LOG"), 0);
// check input parameters
if (String.IsNullOrEmpty(mailTo))
{
TaskManager.WriteWarning("Specify 'Mail To' task parameter");
return;
}
string mailFrom = null;
SystemSettings settings = SystemController.GetSystemSettingsInternal(SystemSettings.SMTP_SETTINGS, false);
if (settings != null)
{
mailFrom = settings["SmtpUsername"];
}
if (String.IsNullOrEmpty(mailFrom))
{
TaskManager.WriteWarning("You need to configure SMTP settings first");
return;
}
DateTime logStart, logEnd;
switch (auditLogDate)
{
case "today":
logStart = DateTime.Now;
logEnd = DateTime.Now;
break;
case "yesterday":
logStart = DateTime.Now.AddDays(-1);
logEnd = DateTime.Now.AddDays(-1);
break;
case "schedule":
default:
logEnd = DateTime.Now;
ScheduleInfo schedule = SchedulerController.GetSchedule(topTask.ScheduleId);
switch (schedule.ScheduleTypeId)
{
case "Daily":
logStart = DateTime.Now.AddDays(-1);
break;
case "Weekly":
logStart = DateTime.Now.AddDays(-7);
break;
case "Monthly":
logStart = DateTime.Now.AddMonths(-1);
break;
case "Interval":
logStart = DateTime.Now.AddSeconds(-schedule.Interval);
break;
case "OneTime":
default:
logStart = DateTime.Now;
break;
}
break;
}
string mailSubject = "Audit Log Report (" + logStart.ToString("MMM dd, yyyy") + " - " + logEnd.ToString("MMM dd, yyyy") + ")";
StringBuilder sb = new StringBuilder();
sb.AppendLine("<html><head><style>");
sb.AppendLine("table, th, td { border: 1px solid black; border-collapse: collapse; }");
sb.AppendLine("th, td { padding: 5px; }");
sb.AppendLine("th { text-align: left; }");
sb.AppendLine("</style></head><body>");
sb.AppendLine("<h2>" + mailSubject + "</h2>");
sb.AppendFormat("<h3>Source: {0}, Task: {1}, Severity: {2}</h3>", String.IsNullOrEmpty(auditLogSource) ? "All" : auditLogSource,
String.IsNullOrEmpty(auditLogTask) ? "All" : auditLogTask, GetAuditLogRecordSeverityName(auditLogSeverity));
DataTable logs = AuditLog.GetAuditLogRecordsPaged(topTask.EffectiveUserId, 0, 0, null, logStart, logEnd,
auditLogSeverity, auditLogSource, auditLogTask, "", 0, Int32.MaxValue).Tables[1];
sb.AppendLine("<p>");
if (logs.Rows.Count == 0)
{
sb.AppendLine("Audit Log is empty.");
}
else
{
sb.AppendLine("<table>");
sb.Append("<tr><th>Started</th><th>Finished</th><th>Severity</th><th>Username</th><th>Source</th><th>Task</th><th>Item-Name</th>");
if (showExecutionLog == 1)
{
sb.AppendLine("<th>Execution-Log</th></tr>");
}
else
{
sb.AppendLine("</tr>");
}
foreach (DataRow log in logs.Rows)
{
sb.AppendLine("<tr>");
// Started
sb.AppendFormat("<td>{0}</td>", log["StartDate"].ToString());
// Finished
sb.AppendFormat("<td>{0}</td>", log["FinishDate"].ToString());
// Severity
sb.AppendFormat("<td>{0}</td>", GetAuditLogRecordSeverityName((int)log["SeverityID"]));
// Username
sb.AppendFormat("<td>{0}</td>", log["Username"]);
// Source
sb.AppendFormat("<td>{0}</td>", log["SourceName"]);
// Task
sb.AppendFormat("<td>{0}</td>", log["TaskName"]);
// Item-Name
sb.AppendFormat("<td>{0}</td>", log["ItemName"]);
// Execution-Log
if (showExecutionLog == 1)
{
string executionLog = FormatPlainTextExecutionLog(log["ExecutionLog"].ToString());
sb.AppendFormat("<td>{0}</td>", executionLog);
}
sb.AppendLine("</tr>");
}
sb.AppendLine("</table>");
}
sb.AppendLine("</p></body></html>");
// send mail message
int res = MailHelper.SendMessage(mailFrom, mailTo, mailSubject, sb.ToString(), true);
if (res != 0)
{
TaskManager.WriteError("SMTP Error. Code: " + res.ToString());
}
}
public static int AuthenticateUser(string username, string password, string ip)
{
// start task
TaskManager.StartTask("USER", "AUTHENTICATE", username);
TaskManager.WriteParameter("IP", ip);
try
{
int result = 0;
// try to get user from database
UserInfoInternal user = GetUserInternally(username);
// check if the user exists
if (user == null)
{
TaskManager.WriteWarning("Wrong username");
return(BusinessErrorCodes.ERROR_USER_WRONG_USERNAME);
}
// check if the user is disabled
if (user.LoginStatus == UserLoginStatus.Disabled)
{
TaskManager.WriteWarning("User disabled");
return(BusinessErrorCodes.ERROR_USER_ACCOUNT_DISABLED);
}
// check if the user is locked out
if (user.LoginStatus == UserLoginStatus.LockedOut)
{
TaskManager.WriteWarning("User locked out");
return(BusinessErrorCodes.ERROR_USER_ACCOUNT_LOCKEDOUT);
}
//Get the password policy
UserSettings userSettings = UserController.GetUserSettings(user.UserId, UserSettings.SolidCP_POLICY);
int lockOut = -1;
if (!string.IsNullOrEmpty(userSettings["PasswordPolicy"]))
{
string passwordPolicy = userSettings["PasswordPolicy"];
try
{
// parse settings
string[] parts = passwordPolicy.Split(';');
lockOut = Convert.ToInt32(parts[7]);
}
catch { /* skip */ }
}
// compare user passwords
if ((CryptoUtils.SHA1(user.Password) == password) || (user.Password == password))
{
switch (user.OneTimePasswordState)
{
case OneTimePasswordStates.Active:
result = BusinessSuccessCodes.SUCCESS_USER_ONETIMEPASSWORD;
OneTimePasswordHelper.FireSuccessAuth(user);
break;
case OneTimePasswordStates.Expired:
if (lockOut >= 0)
{
DataProvider.UpdateUserFailedLoginAttempt(user.UserId, lockOut, false);
}
TaskManager.WriteWarning("Expired one time password");
return(BusinessErrorCodes.ERROR_USER_EXPIRED_ONETIMEPASSWORD);
break;
}
}
else
{
if (lockOut >= 0)
{
DataProvider.UpdateUserFailedLoginAttempt(user.UserId, lockOut, false);
}
TaskManager.WriteWarning("Wrong password");
return(BusinessErrorCodes.ERROR_USER_WRONG_PASSWORD);
}
DataProvider.UpdateUserFailedLoginAttempt(user.UserId, lockOut, true);
// check status
if (user.Status == UserStatus.Cancelled)
{
TaskManager.WriteWarning("Account cancelled");
return(BusinessErrorCodes.ERROR_USER_ACCOUNT_CANCELLED);
}
if (user.Status == UserStatus.Pending)
{
TaskManager.WriteWarning("Account pending");
return(BusinessErrorCodes.ERROR_USER_ACCOUNT_PENDING);
}
return(result);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public override void DoWork()
{
// Input parameters:
// - DATABASE_GROUP
// - DATABASE_NAME
// - BACKUP_FOLDER
// - BACKUP_NAME
// - ZIP_BACKUP
BackgroundTask topTask = TaskManager.TopTask;
string databaseGroup = (string)topTask.GetParamValue("DATABASE_GROUP");
string databaseName = (string)topTask.GetParamValue("DATABASE_NAME");
string backupFolder = (string)topTask.GetParamValue("BACKUP_FOLDER");
string backupName = (string)topTask.GetParamValue("BACKUP_NAME");
string strZipBackup = (string)topTask.GetParamValue("ZIP_BACKUP");
// check input parameters
if (String.IsNullOrEmpty(databaseName))
{
TaskManager.WriteWarning("Specify 'Database Name' task parameter.");
return;
}
bool zipBackup = (strZipBackup.ToLower() == "true");
if (String.IsNullOrEmpty(backupName))
{
backupName = databaseName + (zipBackup ? ".zip" : ".bak");
}
else
{
// check extension
string ext = Path.GetExtension(backupName);
if (zipBackup && String.Compare(ext, ".zip", true) != 0)
{
// change extension to .zip
backupName = Path.GetFileNameWithoutExtension(backupName) + ".zip";
}
}
// try to find database
SqlDatabase item = (SqlDatabase)PackageController.GetPackageItemByName(topTask.PackageId, databaseGroup,
databaseName, typeof(SqlDatabase));
if (item == null)
{
TaskManager.WriteError("Database with the specified name was not found in the current hosting space.");
return;
}
if (String.IsNullOrEmpty(backupFolder))
{
backupFolder = "\\";
}
// substitute parameters
DateTime d = DateTime.Now;
string date = d.ToString("yyyyMMdd");
string time = d.ToString("HHmm");
backupFolder = Utils.ReplaceStringVariable(backupFolder, "date", date);
backupFolder = Utils.ReplaceStringVariable(backupFolder, "time", time);
backupName = Utils.ReplaceStringVariable(backupName, "date", date);
backupName = Utils.ReplaceStringVariable(backupName, "time", time);
// backup database
DatabaseServerController.BackupSqlDatabase(item.Id, backupName, zipBackup, false, backupFolder);
}
public static int SendPasswordReminder(string username, string ip)
{
// place log record
TaskManager.StartTask("USER", "SEND_REMINDER", username);
TaskManager.WriteParameter("IP", ip);
try
{
// try to get user from database
UserInfoInternal user = GetUserInternally(username);
if (user == null)
{
TaskManager.WriteWarning("Account not found");
// Fix for item #273 (NGS-9)
//return BusinessErrorCodes.ERROR_USER_NOT_FOUND;
return(0);
}
UserSettings settings = UserController.GetUserSettings(user.UserId, UserSettings.PASSWORD_REMINDER_LETTER);
string from = settings["From"];
string cc = settings["CC"];
string subject = settings["Subject"];
string body = user.HtmlMail ? settings["HtmlBody"] : settings["TextBody"];
bool isHtml = user.HtmlMail;
MailPriority priority = MailPriority.Normal;
if (!String.IsNullOrEmpty(settings["Priority"]))
{
priority = (MailPriority)Enum.Parse(typeof(MailPriority), settings["Priority"], true);
}
if (body == null || body == "")
{
return(BusinessErrorCodes.ERROR_SETTINGS_PASSWORD_LETTER_EMPTY_BODY);
}
// One Time Password feature
user.Password = OneTimePasswordHelper.SetOneTimePassword(user.UserId);
// set template context items
Hashtable items = new Hashtable();
items["user"] = user;
items["Email"] = true;
// get reseller details
UserInfoInternal reseller = UserController.GetUser(user.OwnerId);
if (reseller != null)
{
items["reseller"] = new UserInfo(reseller);
}
subject = PackageController.EvaluateTemplate(subject, items);
body = PackageController.EvaluateTemplate(body, items);
// send message
MailHelper.SendMessage(from, user.Email, cc, subject, body, priority, isHtml);
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int AddUser(UserInfo user, bool sendLetter, string password)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
if (accountCheck < 0)
{
return(accountCheck);
}
string pattern = @"[\\/:*?<>|""]+";
if (String.IsNullOrEmpty(user.Username))
{
return(BusinessErrorCodes.ERROR_INVALID_USER_NAME);
}
if (Regex.IsMatch(user.Username, pattern))
{
return(BusinessErrorCodes.ERROR_INVALID_USER_NAME);
}
if (UserExists(user.Username))
{
return(BusinessErrorCodes.ERROR_USER_ALREADY_EXISTS);
}
// only administrators can set admin role
if (!SecurityContext.User.IsInRole(SecurityContext.ROLE_ADMINISTRATOR) &&
user.Role == UserRole.Administrator)
{
user.Role = UserRole.User;
}
// check integrity when creating a user account
if (user.Role == UserRole.User)
{
user.EcommerceEnabled = false;
}
// place log record
TaskManager.StartTask("USER", "ADD", user.Username);
try
{
// add user to database
int userId = DataProvider.AddUser(
SecurityContext.User.UserId,
user.OwnerId,
user.RoleId,
user.StatusId,
user.SubscriberNumber,
user.LoginStatusId,
user.IsDemo,
user.IsPeer,
user.Comments,
user.Username.Trim(),
CryptoUtils.Encrypt(password),
user.FirstName,
user.LastName,
user.Email,
user.SecondaryEmail,
user.Address,
user.City,
user.Country,
user.State,
user.Zip,
user.PrimaryPhone,
user.SecondaryPhone,
user.Fax,
user.InstantMessenger,
user.HtmlMail,
user.CompanyName,
user.EcommerceEnabled);
if (userId == -1)
{
TaskManager.WriteWarning("Account with such username already exists");
return(BusinessErrorCodes.ERROR_USER_ALREADY_EXISTS);
}
BackgroundTask topTask = TaskManager.TopTask;
topTask.ItemId = userId;
topTask.UpdateParamValue("SendLetter", sendLetter);
TaskController.UpdateTaskWithParams(topTask);
return(userId);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public override void DoWork()
{
BackgroundTask topTask = TaskManager.TopTask;
List <DomainDnsChanges> domainsChanges = new List <DomainDnsChanges>();
var domainUsers = new Dictionary <int, UserInfo>();
// get input parameters
string dnsServersString = (string)topTask.GetParamValue(DnsServersParameter);
string serverName = (string)topTask.GetParamValue(ServerNameParameter);
int pause;
// check input parameters
if (String.IsNullOrEmpty(dnsServersString))
{
TaskManager.WriteWarning("Specify 'DNS' task parameter.");
return;
}
if (String.IsNullOrEmpty((string)topTask.GetParamValue("MAIL_TO")))
{
TaskManager.WriteWarning("The e-mail message has not been sent because 'Mail To' is empty.");
return;
}
if (!int.TryParse((string)topTask.GetParamValue(PauseBetweenQueriesParameter), out pause))
{
TaskManager.WriteWarning("The 'pause between queries' parameter is not valid.");
return;
}
// find server by name
ServerInfo server = ServerController.GetServerByName(serverName);
if (server == null)
{
TaskManager.WriteWarning(String.Format("Server with the name '{0}' was not found", serverName));
return;
}
WindowsServer winServer = new WindowsServer();
ServiceProviderProxy.ServerInit(winServer, server.ServerId);
var user = UserController.GetUser(topTask.UserId);
var dnsServers = dnsServersString.Split(';');
var packages = ObjectUtils.CreateListFromDataReader <PackageInfo>(DataProvider.GetAllPackages());
foreach (var package in packages)
{
var domains = ServerController.GetDomains(package.PackageId);
domains = domains.Where(x => !x.IsSubDomain && !x.IsDomainPointer).ToList(); //Selecting top-level domains
//domains = domains.Where(x => x.ZoneItemId > 0).ToList(); //Selecting only dns enabled domains
foreach (var domain in domains)
{
if (domainsChanges.Any(x => x.DomainName == domain.DomainName))
{
continue;
}
if (!domainUsers.ContainsKey(domain.PackageId))
{
var domainUser = UserController.GetUser(packages.First(x => x.PackageId == domain.PackageId).UserId);
domainUsers.Add(domain.PackageId, domainUser);
}
DomainDnsChanges domainChanges = new DomainDnsChanges();
domainChanges.DomainName = domain.DomainName;
domainChanges.PackageId = domain.PackageId;
domainChanges.Registrar = domain.RegistrarName;
domainChanges.ExpirationDate = domain.ExpirationDate;
var dbDnsRecords = ObjectUtils.CreateListFromDataReader <DnsRecordInfo>(DataProvider.GetDomainAllDnsRecords(domain.DomainId));
//execute server
foreach (var dnsServer in dnsServers)
{
var dnsMxRecords = GetDomainDnsRecords(winServer, domain.DomainName, dnsServer, DnsRecordType.MX, pause) ?? dbDnsRecords.Where(x => x.RecordType == DnsRecordType.MX).ToList();
var dnsNsRecords = GetDomainDnsRecords(winServer, domain.DomainName, dnsServer, DnsRecordType.NS, pause) ?? dbDnsRecords.Where(x => x.RecordType == DnsRecordType.NS).ToList();
FillRecordData(dnsMxRecords, domain, dnsServer);
FillRecordData(dnsNsRecords, domain, dnsServer);
domainChanges.DnsChanges.AddRange(ApplyDomainRecordsChanges(dbDnsRecords.Where(x => x.RecordType == DnsRecordType.MX), dnsMxRecords, dnsServer));
domainChanges.DnsChanges.AddRange(ApplyDomainRecordsChanges(dbDnsRecords.Where(x => x.RecordType == DnsRecordType.NS), dnsNsRecords, dnsServer));
domainChanges.DnsChanges = CombineDnsRecordChanges(domainChanges.DnsChanges, dnsServer).ToList();
}
domainsChanges.Add(domainChanges);
}
}
var changedDomains = FindDomainsWithChangedRecords(domainsChanges);
SendMailMessage(user, changedDomains, domainUsers);
}
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(DnsZone))
{
// Get ascii form in punycode
var zoneName = GetAsciiZoneName(itemName);
// add DNS zone
DnsZone zone = new DnsZone();
zone.Name = zoneName;
zone.ServiceId = serviceId;
zone.PackageId = packageId;
int zoneId = PackageController.AddPackageItem(zone);
// Add secondary zone(s)
try
{
// get secondary DNS services
var primSettings = ServerController.GetServiceSettings(serviceId);
var secondaryServiceIds = new List <int>();
var strSecondaryServices = primSettings["SecondaryDNSServices"];
if (!String.IsNullOrEmpty(strSecondaryServices))
{
var secondaryServices = strSecondaryServices.Split(',');
secondaryServiceIds.AddRange(secondaryServices.Select(strSecondaryId => Utils.ParseInt(strSecondaryId, 0)).Where(secondaryId => secondaryId != 0));
}
// add secondary zones
var secondaryZoneFound = false;
foreach (var secondaryId in secondaryServiceIds)
{
var secDns = GetDNSServer(secondaryId);
if (secDns.ZoneExists(zoneName))
{
secondaryZoneFound = true;
var secondaryZone = new SecondaryDnsZone
{
Name = zoneName,
ServiceId = secondaryId,
PackageId = packageId
};
PackageController.AddPackageItem(secondaryZone);
}
}
if (!secondaryZoneFound)
{
TaskManager.WriteWarning("No secondary zone(s) found when importing zone " + itemName);
}
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "Error importing secondary zone(s)");
}
// add/update domains/pointers
RestoreDomainByZone(itemName, packageId, zoneId);
}
}
public override void DoWork()
{
// Input parameters:
// - FILE_PATH
// - FTP_SERVER
// - FTP_USERNAME
// - FTP_PASSWORD
// - FTP_FOLDER
BackgroundTask topTask = TaskManager.TopTask;
// get input parameters
string filePath = (string)topTask.GetParamValue("FILE_PATH");
string ftpServer = (string)topTask.GetParamValue("FTP_SERVER");
string ftpUsername = (string)topTask.GetParamValue("FTP_USERNAME");
string ftpPassword = (string)topTask.GetParamValue("FTP_PASSWORD");
string ftpFolder = (string)topTask.GetParamValue("FTP_FOLDER");
// check input parameters
if (String.IsNullOrEmpty(filePath))
{
TaskManager.WriteWarning("Specify 'File' task parameter");
return;
}
if (String.IsNullOrEmpty(ftpServer))
{
TaskManager.WriteWarning("Specify 'FTP Server' task parameter");
return;
}
// substitute parameters
DateTime d = DateTime.Now;
string date = d.ToString("yyyyMMdd");
string time = d.ToString("HHmm");
filePath = Utils.ReplaceStringVariable(filePath, "date", date);
filePath = Utils.ReplaceStringVariable(filePath, "time", time);
// build FTP command file
StringBuilder sb = new StringBuilder();
StringWriter writer = new StringWriter(sb);
// FTP server
writer.WriteLine("open " + ftpServer);
// check if anonymous mode
if (String.IsNullOrEmpty(ftpUsername))
{
ftpUsername = "******";
ftpPassword = "******";
}
// FTP username/password
writer.WriteLine(ftpUsername);
writer.WriteLine(ftpPassword);
// check if we need to change remote folder
if (!String.IsNullOrEmpty(ftpFolder))
{
writer.WriteLine("cd " + ftpFolder.Replace("\\", "/"));
}
// file to send
writer.WriteLine("binary");
writer.WriteLine("put " + FilesController.GetFullPackagePath(topTask.PackageId, filePath));
// bye
writer.WriteLine("bye");
string cmdBatch = sb.ToString();
// create temp file in user space
string cmdPath = Utils.GetRandomString(10) + ".txt";
string fullCmdPath = FilesController.GetFullPackagePath(topTask.PackageId, cmdPath);
// upload batch
FilesController.UpdateFileBinaryContent(topTask.PackageId, cmdPath, Encoding.UTF8.GetBytes(cmdBatch));
// execute system command
// load OS service
int serviceId = PackageController.GetPackageServiceId(topTask.PackageId, ResourceGroups.Os);
// load service
ServiceInfo service = ServerController.GetServiceInfo(serviceId);
if (service == null)
{
return;
}
WindowsServer winServer = new WindowsServer();
ServiceProviderProxy.ServerInit(winServer, service.ServerId);
TaskManager.Write(winServer.ExecuteSystemCommand("ftp.exe", "-s:" + fullCmdPath));
// delete batch file
FilesController.DeleteFiles(topTask.PackageId, new string[] { cmdPath });
}
public override void DoWork()
{
// Input parameters:
// - URL
// - USERNAME
// - PASSWORD
// - RESPONSE_STATUS
// - RESPONSE_CONTAIN
// - RESPONSE_DOESNT_CONTAIN
// - MAIL_FROM
// - MAIL_TO
// - MAIL_SUBJECT
// - MAIL_BODY
BackgroundTask topTask = TaskManager.TopTask;
// get input parameters
string url = (string)topTask.GetParamValue("URL");
string username = (string)topTask.GetParamValue("USERNAME");
string password = (string)topTask.GetParamValue("PASSWORD");
string strResponseStatus = (string)topTask.GetParamValue("RESPONSE_STATUS");
string responseContains = (string)topTask.GetParamValue("RESPONSE_CONTAIN");
string responseNotContains = (string)topTask.GetParamValue("RESPONSE_DOESNT_CONTAIN");
bool useResponseStatus = Convert.ToBoolean(topTask.GetParamValue("USE_RESPONSE_STATUS"));
bool useResponseContains = Convert.ToBoolean(topTask.GetParamValue("USE_RESPONSE_CONTAIN"));
bool useResponseDoesntContain = Convert.ToBoolean(topTask.GetParamValue("USE_RESPONSE_DOESNT_CONTAIN"));
// check input parameters
if (String.IsNullOrEmpty(url))
{
TaskManager.WriteWarning("Specify 'Web Site URL' task parameter.");
return;
}
if ((String.IsNullOrEmpty(strResponseStatus) || !useResponseStatus) &&
(String.IsNullOrEmpty(responseContains) || !useResponseContains) &&
(String.IsNullOrEmpty(responseNotContains) || !useResponseDoesntContain))
{
TaskManager.WriteWarning("Specify one of 'Response Status', 'Response Contain' or 'Response Doesn't Contain' parameters.");
return;
}
int responseStatus = Utils.ParseInt(strResponseStatus, -1);
if (!String.IsNullOrEmpty(strResponseStatus) && responseStatus == -1)
{
TaskManager.WriteWarning("Specify correct response HTTP status, e.g. 404, 500, 503, etc.");
return;
}
// load web site
WebSiteResponse resp = GetWebDocument(url, username, password);
// check if there was a generic error
if (resp.Status == -1)
{
SendMailMessage(url, resp.Text, "");
}
bool sendMessage = false;
// check status
if (responseStatus != -1)
{
sendMessage |= ((resp.Status == responseStatus) && useResponseStatus);
}
// check "contains"
if (!String.IsNullOrEmpty(responseContains))
{
sendMessage |= ((resp.Text.ToLower().IndexOf(responseContains.ToLower()) != -1) && useResponseContains);
}
// check "not contains"
if (!String.IsNullOrEmpty(responseNotContains))
{
sendMessage |= ((resp.Text.ToLower().IndexOf(responseNotContains.ToLower()) == -1) && useResponseDoesntContain);
}
if (sendMessage)
{
SendMailMessage(url, "", resp.Text);
}
}
public override void DoWork()
{
BackgroundTask topTask = TaskManager.TopTask;
var domainUsers = new Dictionary <int, UserInfo>();
var checkedDomains = new List <DomainInfo>();
var expiredDomains = new List <DomainInfo>();
var nonExistenDomains = new List <DomainInfo>();
var allDomains = new List <DomainInfo>();
var allTopLevelDomains = new List <DomainInfo>();
// get input parameters
int daysBeforeNotify;
bool sendEmailNotifcation = Convert.ToBoolean(topTask.GetParamValue(EnableNotification));
bool includeNonExistenDomains = Convert.ToBoolean(topTask.GetParamValue(IncludeNonExistenDomains));
// check input parameters
if (String.IsNullOrEmpty((string)topTask.GetParamValue("MAIL_TO")))
{
TaskManager.WriteWarning("The e-mail message has not been sent because 'Mail To' is empty.");
return;
}
int.TryParse((string)topTask.GetParamValue(DaysBeforeNotify), out daysBeforeNotify);
var user = UserController.GetUser(topTask.EffectiveUserId);
var packages = GetUserPackages(user.UserId, user.Role);
foreach (var package in packages)
{
var domains = ServerController.GetDomains(package.PackageId);
allDomains.AddRange(domains);
domains = domains.Where(x => !x.IsSubDomain && !x.IsDomainPointer).ToList(); //Selecting top-level domains
allTopLevelDomains.AddRange(domains);
var domainUser = UserController.GetUser(package.UserId);
if (!domainUsers.ContainsKey(package.PackageId))
{
domainUsers.Add(package.PackageId, domainUser);
}
foreach (var domain in domains)
{
if (checkedDomains.Any(x => x.DomainId == domain.DomainId))
{
continue;
}
checkedDomains.Add(domain);
ServerController.UpdateDomainWhoisData(domain);
if (CheckDomainExpiration(domain.ExpirationDate, daysBeforeNotify))
{
expiredDomains.Add(domain);
}
if (domain.ExpirationDate == null && domain.CreationDate == null)
{
nonExistenDomains.Add(domain);
}
Thread.Sleep(100);
}
}
var subDomains = allDomains.Where(x => !checkedDomains.Any(z => z.DomainId == x.DomainId && z.ExpirationDate != null)).GroupBy(p => p.DomainId).Select(g => g.First()).ToList();
foreach (var subDomain in subDomains)
{
var mainDomain = checkedDomains.Where(x => subDomain.DomainId != x.DomainId && subDomain.DomainName.ToLowerInvariant().Contains(x.DomainName.ToLowerInvariant())).OrderByDescending(s => s.DomainName.Length).FirstOrDefault();;
if (mainDomain != null)
{
ServerController.UpdateDomainWhoisData(subDomain, mainDomain.CreationDate, mainDomain.ExpirationDate, mainDomain.RegistrarName);
var nonExistenDomain = nonExistenDomains.FirstOrDefault(x => subDomain.DomainId == x.DomainId);
if (nonExistenDomain != null)
{
nonExistenDomains.Remove(nonExistenDomain);
}
Thread.Sleep(100);
}
}
expiredDomains = expiredDomains.GroupBy(p => p.DomainId).Select(g => g.First()).ToList();
if (expiredDomains.Count > 0 && sendEmailNotifcation)
{
SendMailMessage(user, expiredDomains, domainUsers, nonExistenDomains, includeNonExistenDomains);
}
}
