public static int CloseTerminalServicesSession(int serverId, int sessionId) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsAdmin | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // load server info ServerInfo server = ServerController.GetServerById(serverId, false); // place log record TaskManager.StartTask("SERVER", "RESET_TERMINAL_SESSION", sessionId, serverId); try { GetServerService(serverId).CloseTerminalServicesSession(sessionId); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public void ChangePackagesServiceItemsState() { // impersonate thread if (userId != -1) { SecurityContext.SetThreadPrincipal(userId); } TaskManager.StartTask("SPACE", "CHANGE_ITEMS_STATUS"); // collect required service items List <ServiceProviderItem> items = new List <ServiceProviderItem>(); foreach (PackageInfo package in packages) { items.AddRange(PackageController.GetServiceItemsForStatistics( 0, package.PackageId, false, false, true, false)); // suspendable items } // order items by service Dictionary <int, List <ServiceProviderItem> > orderedItems = PackageController.OrderServiceItemsByServices(items); // process items bool enabled = (ItemsStatus == PackageStatus.Active); foreach (int serviceId in orderedItems.Keys) { ProcessServiceItems(true, enabled, serviceId, orderedItems[serviceId]); } // add log record TaskManager.CompleteTask(); }
public static int ChangeUserPassword(int userId, string password) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } // get user details UserInfo user = GetUserInternally(userId); // place log record TaskManager.StartTask("USER", "CHANGE_PASSWORD", user.Username, user.UserId); try { DataProvider.ChangeUserPassword(SecurityContext.User.UserId, userId, CryptoUtils.Encrypt(password)); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int TerminateWindowsProcess(int serverId, int pid) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsAdmin | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // load server info ServerInfo server = ServerController.GetServerById(serverId); // place log record TaskManager.StartTask("SERVER", "TERMINATE_SYSTEM_PROCESS", pid); TaskManager.ItemId = serverId; try { GetServerService(serverId).TerminateWindowsProcess(pid); return(0); } 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(); } }
private static void SetStorageSpaceFolderEncryptDataAccessStatusInternal(int storageSpaceFolderId, bool enabled) { TaskManager.StartTask("STORAGE_SPACES", "SET_ENCRYPT_DATA_ACCESS_STATUS"); try { var folder = GetStorageSpaceFolderById(storageSpaceFolderId); if (folder == null) { throw new Exception(string.Format("Storage space folder with id={0} not found", storageSpaceFolderId)); } var storageSpace = StorageSpacesController.GetStorageSpaceById(folder.StorageSpaceId); if (storageSpace == null) { throw new Exception(string.Format("Storage space with id={0} not found", folder.StorageSpaceId)); } var ss = GetStorageSpaceService(storageSpace.ServiceId); ss.ShareSetEncyptDataAccess(folder.Path, enabled); } catch (Exception exception) { throw TaskManager.WriteError(exception); } finally { TaskManager.CompleteTask(); } }
public static int ClearLog(int serverId, string logName) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsAdmin | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } TaskManager.StartTask("SERVER", "CLEAR_EVENT_LOG", logName); TaskManager.ItemId = serverId; try { GetServerService(serverId).ClearLog(logName); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } return(0); }
public static int RebootSystem(int serverId) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsAdmin | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // load server info ServerInfo server = ServerController.GetServerById(serverId); // place log record TaskManager.StartTask("SERVER", "REBOOT"); TaskManager.ItemId = serverId; try { GetServerService(serverId).RebootSystem(); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int SetFilePermissions(int packageId, string path, UserPermission[] users, bool resetChildPermissions) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // place log record TaskManager.StartTask("FILES", "SET_PERMISSIONS", path, packageId); try { OS.OperatingSystem os = GetOS(packageId); string fullPath = GetFullPackagePath(packageId, path); // get users OU defined on web server string usersOU = WebServerController.GetWebUsersOU(packageId); os.GrantGroupNtfsPermissions(fullPath, users, usersOU, resetChildPermissions); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int CalculatePackageDiskspace(int packageId) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } // place log record TaskManager.StartTask("SPACE", "CALCULATE_DISKSPACE", packageId); try { // create thread parameters ThreadStartParameters prms = new ThreadStartParameters(); prms.UserId = SecurityContext.User.UserId; prms.Parameters = new object[] { packageId }; Thread t = new Thread(new ParameterizedThreadStart(CalculatePackageDiskspaceAsync)); t.Start(prms); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
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 ChangeWindowsServiceStatus(int serverId, string id, WindowsServiceStatus status) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsAdmin | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // load server info ServerInfo server = ServerController.GetServerById(serverId); // place log record TaskManager.StartTask("SERVER", "CHANGE_WINDOWS_SERVICE_STATUS", id); TaskManager.ItemId = serverId; TaskManager.WriteParameter("New Status", status); try { GetServerService(serverId).ChangeWindowsServiceStatus(id, status); 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 static int ZipFiles(int packageId, string[] files, string archivePath) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // check package int packageCheck = SecurityContext.CheckPackage(packageId, DemandPackage.IsActive); if (packageCheck < 0) { return(packageCheck); } // place log record TaskManager.StartTask("FILES", "ZIP_FILES", archivePath, packageId); if (files != null) { foreach (string file in files) { TaskManager.Write(file); } } try { OS.OperatingSystem os = GetOS(packageId); string zipFilePath = GetFullPackagePath(packageId, archivePath); List <string> archFiles = new List <string>(); string rootFolder = ""; foreach (string file in files) { string archFile = GetFullPackagePath(packageId, file); int idx = archFile.LastIndexOf("\\"); rootFolder = archFile.Substring(0, idx); archFiles.Add(archFile.Substring(idx + 1)); } os.ZipFiles(zipFilePath, rootFolder, archFiles.ToArray()); return(0); } catch (Exception ex) { //Log and return a generic error rather than throwing an exception TaskManager.WriteError(ex); return(BusinessErrorCodes.ERROR_FILE_GENERIC_LOGGED); } finally { TaskManager.CompleteTask(); } }
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, 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(); } }
public static int UpdateSite(StatsSite item) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // load original meta item StatsSite origItem = (StatsSite)PackageController.GetPackageItem(item.Id); if (origItem == null) { return(BusinessErrorCodes.ERROR_STATS_PACKAGE_ITEM_NOT_FOUND); } // check package int packageCheck = SecurityContext.CheckPackage(origItem.PackageId, DemandPackage.IsActive); if (packageCheck < 0) { return(packageCheck); } // update statistics site item.Name = origItem.Name; item.SiteId = origItem.SiteId; // place log record TaskManager.StartTask("STATS_SITE", "UPDATE", origItem.Name, origItem.Id); try { StatisticsServer stats = new StatisticsServer(); ServiceProviderProxy.Init(stats, origItem.ServiceId); stats.UpdateSite(item); // update service item PackageController.UpdatePackageItem(item); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static string[] UnzipFiles(int packageId, string[] files) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(null); } // check package int packageCheck = SecurityContext.CheckPackage(packageId, DemandPackage.IsActive); if (packageCheck < 0) { return(null); } // place log record TaskManager.StartTask("FILES", "UNZIP_FILES", packageId); if (files != null) { foreach (string file in files) { TaskManager.Write(file); } } try { List <string> unzippedFiles = new List <string>(); OS.OperatingSystem os = GetOS(packageId); for (int i = 0; i < files.Length; i++) { string zipFilePath = GetFullPackagePath(packageId, files[i]); string destFolderPath = zipFilePath.Substring(0, zipFilePath.LastIndexOf("\\")); unzippedFiles.AddRange(os.UnzipFiles(zipFilePath, destFolderPath)); } return(unzippedFiles.ToArray()); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
// Implementation of ThreadStart delegate. // Used by Scheduler to kick off events on a seperate thread private void RunSchedule() { // impersonate thread UserInfo user = PackageController.GetPackageOwner(scheduleInfo.PackageId); SecurityContext.SetThreadPrincipal(user.UserId); List <BackgroundTaskParameter> parameters = new List <BackgroundTaskParameter>(); foreach (ScheduleTaskParameterInfo prm in scheduleInfo.Parameters) { parameters.Add(new BackgroundTaskParameter(prm.ParameterId, prm.ParameterValue)); } TaskManager.StartTask("SCHEDULER", "RUN_SCHEDULE", scheduleInfo.ScheduleName, scheduleInfo.ScheduleId, scheduleInfo.ScheduleId, scheduleInfo.PackageId, scheduleInfo.MaxExecutionTime, parameters); // run task try { // create scheduled task object SchedulerTask objTask = (SchedulerTask)Activator.CreateInstance(Type.GetType(task.TaskType)); if (objTask != null) { objTask.DoWork(); } else { throw new Exception(String.Format("Could not create scheduled task of '{0}' type", task.TaskType)); } // Thread.Sleep(40000); } catch (Exception ex) { // log error TaskManager.WriteError(ex, "Error executing scheduled task"); } finally { // complete task try { TaskManager.CompleteTask(); } catch (Exception) { } } }
public static int DeleteWebPartsPackage(int itemId, string packageName) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // load original meta item SharePointSite item = (SharePointSite)PackageController.GetPackageItem(itemId); if (item == null) { return(BusinessErrorCodes.ERROR_SHAREPOINT_PACKAGE_ITEM_NOT_FOUND); } // check package int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive); if (packageCheck < 0) { return(packageCheck); } // place log record TaskManager.StartTask("SHAREPOINT", "UNINSTALL_WEBPARTS", item.Name, itemId); TaskManager.WriteParameter("Package name", packageName); try { SharePointServer sps = GetSharePoint(item.ServiceId); // uninstall webparts if (!String.IsNullOrEmpty(packageName)) { sps.DeleteWebPartsPackage(item.Name, packageName); } return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int UpdateSharePointGroup(SystemGroup item) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // load original meta item SystemGroup origItem = (SystemGroup)PackageController.GetPackageItem(item.Id); if (origItem == null) { return(BusinessErrorCodes.ERROR_SHAREPOINT_GROUPS_PACKAGE_ITEM_NOT_FOUND); } // check package int packageCheck = SecurityContext.CheckPackage(origItem.PackageId, DemandPackage.IsActive); if (packageCheck < 0) { return(packageCheck); } // place log record TaskManager.StartTask("SHAREPOINT", "UPDATE_GROUP", origItem.Name, item.Id); try { // get service SharePointServer sps = GetSharePoint(origItem.ServiceId); item.Description = "SolidCP System Group"; // update service item sps.UpdateGroup(item); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int UpdateUserSettings(UserSettings settings) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } // get user details UserInfo user = GetUserInternally(settings.UserId); // place log record TaskManager.StartTask("USER", "UPDATE_SETTINGS", user.Username, user.UserId); try { // build xml XmlDocument doc = new XmlDocument(); XmlElement nodeProps = doc.CreateElement("properties"); if (settings.SettingsArray != null) { foreach (string[] pair in settings.SettingsArray) { XmlElement nodeProp = doc.CreateElement("property"); nodeProp.SetAttribute("name", pair[0]); nodeProp.SetAttribute("value", pair[1]); nodeProps.AppendChild(nodeProp); } } string xml = nodeProps.OuterXml; // update settings DataProvider.UpdateUserSettings(SecurityContext.User.UserId, settings.UserId, settings.SettingsName, xml); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int CreateFile(int packageId, string path) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // check package int packageCheck = SecurityContext.CheckPackage(packageId, DemandPackage.IsActive); if (packageCheck < 0) { return(packageCheck); } // place log record TaskManager.StartTask("FILES", "CREATE_FILE", path, packageId); try { OS.OperatingSystem os = GetOS(packageId); string fullPath = GetFullPackagePath(packageId, path); // cannot create a file with the same name as a directory if (os.DirectoryExists(fullPath)) { return(BusinessErrorCodes.ERROR_FILE_CREATE_FILE_WITH_DIR_NAME); } // create file os.CreateFile(fullPath); return(0); } catch (Exception ex) { //Log and return a generic error rather than throwing an exception TaskManager.WriteError(ex); return(BusinessErrorCodes.ERROR_FILE_GENERIC_LOGGED); } finally { TaskManager.CompleteTask(); } }
public void DeletePackagesServiceItems() { // impersonate thread if (userId != -1) { SecurityContext.SetThreadPrincipal(userId); } // delete package by package foreach (PackageInfo package in packages) { TaskManager.StartTask("SPACE", "DELETE_ITEMS", package.PackageName); TaskManager.WriteParameter("User", package.UserId); // get package service items List <ServiceProviderItem> items = PackageController.GetServiceItemsForStatistics( 0, package.PackageId, false, false, false, true); // disposable items // order items by service Dictionary <int, List <ServiceProviderItem> > orderedItems = PackageController.OrderServiceItemsByServices(items); // delete service items by service sets foreach (int serviceId in orderedItems.Keys) { ServiceInfo service = ServerController.GetServiceInfo(serviceId); //Delete Exchange Organization if (service.ProviderId == 103 /*Organizations*/) { OrganizationController.DeleteOrganization(orderedItems[serviceId][0].Id); //int exchangeId = PackageController.GetPackageServiceId(package.PackageId, ResourceGroups.Exchange2007); //ExchangeServerController.DeleteOrganization(orderedItems[serviceId][0].Id); } else { ProcessServiceItems(false, false, serviceId, orderedItems[serviceId]); } } // delete package from database DataProvider.DeletePackage(SecurityContext.User.UserId, package.PackageId); } // add log record TaskManager.CompleteTask(); }
public static int DeleteSqlUser(int itemId) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } // load original meta item SqlUser origItem = (SqlUser)PackageController.GetPackageItem(itemId); if (origItem == null) { return(BusinessErrorCodes.ERROR_MSSQL_USERS_PACKAGE_ITEM_NOT_FOUND); } // place log record TaskManager.StartTask("SQL_USER", "DELETE", origItem.Name, itemId); try { // get service DatabaseServer sql = GetDatabaseServer(origItem.ServiceId); // delete service item sql.DeleteUser(origItem.Name, GetSqlDatabasesArray(origItem.PackageId, origItem.GroupName)); // delete meta item PackageController.DeletePackageItem(origItem.Id); 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(); } }
public static int DeleteFiles(int packageId, string[] files) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } // place log record TaskManager.StartTask("FILES", "DELETE_FILES", packageId); if (files != null) { foreach (string file in files) { TaskManager.Write(file); } } try { OS.OperatingSystem os = GetOS(packageId); for (int i = 0; i < files.Length; i++) { files[i] = GetFullPackagePath(packageId, files[i]); } // delete files os.DeleteFiles(files); return(0); } catch (Exception ex) { //Log and return a generic error rather than throwing an exception TaskManager.WriteError(ex); return(BusinessErrorCodes.ERROR_FILE_GENERIC_LOGGED); } finally { TaskManager.CompleteTask(); } }
public static int DeleteSite(int itemId) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } // load original meta item StatsSite origItem = (StatsSite)PackageController.GetPackageItem(itemId); if (origItem == null) { return(BusinessErrorCodes.ERROR_STATS_PACKAGE_ITEM_NOT_FOUND); } // place log record TaskManager.StartTask("STATS_SITE", "DELETE", origItem.Name, itemId); try { // get service StatisticsServer stats = new StatisticsServer(); ServiceProviderProxy.Init(stats, origItem.ServiceId); // delete service item stats.DeleteSite(origItem.SiteId); // delete meta item PackageController.DeletePackageItem(origItem.Id); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int DeleteFtpAccount(int itemId) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } // load original meta item FtpAccount origItem = (FtpAccount)PackageController.GetPackageItem(itemId); if (origItem == null) { return(BusinessErrorCodes.ERROR_FTP_PACKAGE_ITEM_NOT_FOUND); } // place log record TaskManager.StartTask("FTP_ACCOUNT", "DELETE", origItem.Name, itemId); try { // get service FTPServer ftp = new FTPServer(); ServiceProviderProxy.Init(ftp, origItem.ServiceId); // delete service item ftp.DeleteAccount(origItem.Name); // delete meta item PackageController.DeletePackageItem(origItem.Id); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int DeleteOdbcSource(int itemId) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } // load original meta item SystemDSN origItem = (SystemDSN)PackageController.GetPackageItem(itemId); if (origItem == null) { return(BusinessErrorCodes.ERROR_OS_DSN_PACKAGE_ITEM_NOT_FOUND); } // place log record TaskManager.StartTask("ODBC_DSN", "DELETE", origItem.Name); TaskManager.ItemId = itemId; try { // get service OS.OperatingSystem os = GetOS(origItem.ServiceId); // delete service item os.DeleteDSN(origItem.Name); // delete meta item PackageController.DeletePackageItem(origItem.Id); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int DeleteSharePointUser(int itemId) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } // load original meta item SystemUser origItem = (SystemUser)PackageController.GetPackageItem(itemId); if (origItem == null) { return(BusinessErrorCodes.ERROR_SHAREPOINT_USERS_PACKAGE_ITEM_NOT_FOUND); } // place log record TaskManager.StartTask("SHAREPOINT", "DELETE_USER", origItem.Name, itemId); try { // get service SharePointServer sps = GetSharePoint(origItem.ServiceId); // delete service item sps.DeleteUser(origItem.Name); // delete meta item PackageController.DeletePackageItem(origItem.Id); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int CreateBackupZip(int packageId, string archivePath) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // check package int packageCheck = SecurityContext.CheckPackage(packageId, DemandPackage.IsActive); if (packageCheck < 0) { return(packageCheck); } // place log record TaskManager.StartTask("FILES", "ZIP_FILES", archivePath, packageId); try { OS.OperatingSystem os = FilesController.GetOS(packageId); string zipFilePath = FilesController.GetFullPackagePath(packageId, archivePath); string rootFolder = FilesController.GetFullPackagePath(packageId, ""); os.CreateBackupZip(zipFilePath, rootFolder); return(0); } catch (Exception ex) { //Log and return a generic error rather than throwing an exception TaskManager.WriteError(ex); return(BusinessErrorCodes.ERROR_FILE_GENERIC_LOGGED); } finally { TaskManager.CompleteTask(); } }