public static FtpAccount GetFtpAccount(int itemId)
        {
            // load meta item
            FtpAccount item = (FtpAccount)PackageController.GetPackageItem(itemId);
            
            // load service item
            FTPServer ftp = new FTPServer();
            ServiceProviderProxy.Init(ftp, item.ServiceId);
            FtpAccount account = ftp.GetAccount(item.Name);

            // truncate home folder
            account.Folder = FilesController.GetVirtualPackagePath(item.PackageId, account.Folder);

            account.Id = item.Id;
            account.PackageId = item.PackageId;
            account.ServiceId = item.ServiceId;
            account.Password = CryptoUtils.Decrypt(item.Password);

            return account;
        }
 public static FTPServer GetFTPServer(int serviceId)
 {
     FTPServer ftp = new FTPServer();
     ServiceProviderProxy.Init(ftp, serviceId);
     return ftp;
 }
 public static FtpSite[] GetFtpSites(int serviceId)
 {
     FTPServer ftp = new FTPServer();
     ServiceProviderProxy.Init(ftp, serviceId);
     return ftp.GetSites();
 }
        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;

            // FTP provider
            FTPServer ftp = new FTPServer();
            ServiceProviderProxy.Init(ftp, serviceId);

            if (itemType == typeof(FtpAccount))
            {
                    // load FTP account
                    FtpAccount account = ftp.GetAccount(itemName);
                    account.Folder = FilesController.GetFullPackagePath(packageId, "\\"); // root space folder

                    // update FTP account
                    ftp.UpdateAccount(account);

                    // save account
                    account.ServiceId = serviceId;
                    account.PackageId = packageId;
                    PackageController.AddPackageItem(account);
            }
        }
        public List<string> GetImportableItems(int packageId, int itemTypeId, Type itemType, ResourceGroupInfo group)
        {
            List<string> items = new List<string>();

            // get service id
            int serviceId = PackageController.GetPackageServiceId(packageId, group.GroupName);
            if (serviceId == 0)
                return items;

            // FTP provider
            FTPServer ftp = new FTPServer();
            ServiceProviderProxy.Init(ftp, serviceId);

            FtpAccount[] accounts = ftp.GetAccounts();

            foreach (FtpAccount account in accounts)
                items.Add(account.Name);

            return items;
        }
        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 UpdateFtpAccount(FtpAccount item)
        {
            // check account
            int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
            if (accountCheck < 0) return accountCheck;

            // load original meta item
            FtpAccount origItem = (FtpAccount)PackageController.GetPackageItem(item.Id);
            if (origItem == null)
                return BusinessErrorCodes.ERROR_FTP_PACKAGE_ITEM_NOT_FOUND;

            // check package
            int packageCheck = SecurityContext.CheckPackage(origItem.PackageId, DemandPackage.IsActive);
            if (packageCheck < 0) return packageCheck;

            // place log record
            TaskManager.StartTask("FTP_ACCOUNT", "UPDATE", origItem.Name, item.Id);

            TaskManager.WriteParameter("Folder", item.Folder);
            TaskManager.WriteParameter("CanRead", item.CanRead);
            TaskManager.WriteParameter("CanWrite", item.CanWrite);

            try
            {
                // get service
                FTPServer ftp = new FTPServer();
                ServiceProviderProxy.Init(ftp, origItem.ServiceId);

                // store original folder
                string origFolder = item.Folder;

				// convert folder
				StringDictionary ftpSettings = ServerController.GetServiceSettings(origItem.ServiceId);
				if (Utils.ParseBool(ftpSettings["BuildUncFilesPath"], false))
				{
					// UNC
					// get OS service
					int osServiceId = PackageController.GetPackageServiceId(origItem.PackageId, ResourceGroups.Os);
					item.Folder = FilesController.GetFullUncPackagePath(origItem.PackageId, osServiceId, item.Folder);
				}
				else
				{
					// Absolute
					item.Folder = FilesController.GetFullPackagePath(origItem.PackageId, item.Folder);
				}

                item.Enabled = true;

                // add service item
                ftp.UpdateAccount(item);

                // save item
                item.Password = String.IsNullOrEmpty(item.Password) ? origItem.Password : CryptoUtils.Encrypt(item.Password);
                item.Folder = (origFolder == "") ? "\\" : origFolder;
                PackageController.UpdatePackageItem(item);

                return 0;
            }
            catch (Exception ex)
            {
                throw TaskManager.WriteError(ex);
            }
            finally
            {
                TaskManager.CompleteTask();
            }
        }
        public static int AddFtpAccount(FtpAccount item)
        {
            // check account
            int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
            if (accountCheck < 0) return accountCheck;

            // check package
            int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
            if (packageCheck < 0) return packageCheck;

            // check quota
            QuotaValueInfo quota = PackageController.GetPackageQuota(item.PackageId, Quotas.FTP_ACCOUNTS);
            if (quota.QuotaExhausted)
                return BusinessErrorCodes.ERROR_FTP_RESOURCE_QUOTA_LIMIT;

            // check if FTP account already exists
            int serviceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.Ftp);
            if(serviceId == 0)
                return BusinessErrorCodes.ERROR_FTP_RESOURCE_UNAVAILABLE;

            // place log record
            TaskManager.StartTask("FTP_ACCOUNT", "ADD", item.Name);
            TaskManager.WriteParameter("Folder", item.Folder);
            TaskManager.WriteParameter("CanRead", item.CanRead);
            TaskManager.WriteParameter("CanWrite", item.CanWrite);

            
            try
            {
                // check package items
                if (PackageController.GetPackageItemByName(item.PackageId, item.Name, typeof(FtpAccount)) != null)
                    return BusinessErrorCodes.ERROR_FTP_PACKAGE_ITEM_EXISTS;

                // check service items
                FTPServer ftp = new FTPServer();
                ServiceProviderProxy.Init(ftp, serviceId);
                if (ftp.AccountExists(item.Name))
                    return BusinessErrorCodes.ERROR_FTP_SERVICE_ITEM_EXISTS;

				// store original path
				string origFolder = item.Folder;

				// convert folder
				StringDictionary ftpSettings = ServerController.GetServiceSettings(serviceId);
				if (Utils.ParseBool(ftpSettings["BuildUncFilesPath"], false))
				{
					// UNC
					// get OS service
					int osServiceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.Os);
					item.Folder = FilesController.GetFullUncPackagePath(item.PackageId, osServiceId, item.Folder);
				}
				else
				{
					// Absolute
					item.Folder = FilesController.GetFullPackagePath(item.PackageId, item.Folder);
				}

                item.Enabled = true;

                // add service item
                ftp.CreateAccount(item);

                // save item
                item.Password = CryptoUtils.Encrypt(item.Password);
                item.ServiceId = serviceId;
                item.Folder = (origFolder == "") ? "\\" : origFolder;
                int itemId = PackageController.AddPackageItem(item);
                TaskManager.ItemId = itemId;
                return itemId;
                
            }
            catch (Exception ex)
            {
                TaskManager.WriteError(ex);
                throw;
            }
            finally
            {
                TaskManager.CompleteTask();
            }
        }