private static MailAccount ConvertItemToMailAccount(ServiceProviderItem item)
        {
            MailAccount account = (MailAccount)item;
            account.Password = CryptoUtils.Decrypt(account.Password);

            return account;
        }

        // static methods
        public static SoapServiceProviderItem Wrap(ServiceProviderItem item)
        {
            if (item == null)
                return null;

            // wrap only "persistent" properties
            SoapServiceProviderItem sobj = new SoapServiceProviderItem();
            sobj.TypeName = item.GetType().AssemblyQualifiedName;

            // add common properties
            Hashtable props = GetObjectProperties(item, true);
            props.Add("Id", item.Id.ToString());
            props.Add("Name", item.Name);
            props.Add("ServiceId", item.ServiceId.ToString());
            props.Add("PackageId", item.PackageId.ToString());

            List<string> wrProps = new List<string>();
            foreach (string key in props.Keys)
            {
                wrProps.Add(key + "=" + props[key].ToString());
            }

            sobj.Properties = wrProps.ToArray();
            return sobj;
        }

        private static FtpAccount ConvertItemToFtpAccount(ServiceProviderItem item)
        {
            FtpAccount account = (FtpAccount)item;

            string homeFolder = FilesController.GetHomeFolder(account.PackageId);
            if(!String.IsNullOrEmpty(account.Folder) && account.Folder.IndexOf(":") != -1)
                account.Folder = account.Folder.Substring(homeFolder.Length);
            account.Folder = (account.Folder == "") ? "\\" : account.Folder;

            // decode password
            account.Password = CryptoUtils.Decrypt(account.Password);

            return account;
        }

 public override void DeleteServiceItems(ServiceProviderItem[] items)
 {
     foreach (ServiceProviderItem item in items)
     {
         try
         {
             if (item is HomeFolder)
                 // delete home folder
                 FileUtils.DeleteFile(item.Name);
         }
         catch (Exception ex)
         {
             Log.WriteError(String.Format("Error deleting '{0}' {1}", item.Name, item.GetType().Name), ex);
         }
     }
 }

 public virtual ServiceProviderItemBandwidth[] GetServiceItemsBandwidth(ServiceProviderItem[] items, DateTime since)
 {
     // don't calculate bandwidth
     return null;
 }

 public virtual ServiceProviderItemDiskSpace[] GetServiceItemsDiskSpace(ServiceProviderItem[] items)
 {
     // don't calculate disk space
     return null;
 }

        public int BackupItem(string tempFolder, System.Xml.XmlWriter writer, ServiceProviderItem item, ResourceGroupInfo group)
        {
            if (item is HomeFolder)
            {
                // backup home folder files
                string backupName = String.Format("SpaceFiles_{0}_{1}.zip",
                    item.Id, DateTime.Now.Ticks);
                
                // get the list of remote files
                List<SystemFile> files = FilesController.GetFiles(item.PackageId, "\\", true);

                string[] zipFiles = new string[files.Count];
                for(int i = 0; i < zipFiles.Length; i++)
                    zipFiles[i] = files[i].Name;

                // zip remote files
                FilesController.ZipFiles(item.PackageId, zipFiles, backupName);

                // download zipped file
                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 = FilesController.GetFileBinaryChunk(item.PackageId, backupName, 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();

				// delete zipped file
				if (FilesController.FileExists(item.PackageId, backupName))
					FilesController.DeleteFiles(item.PackageId, new string[] { backupName });

                // add file pointer
                BackupController.WriteFileElement(writer, "SpaceFiles", backupName, length);

                // store meta item
                XmlSerializer serializer = new XmlSerializer(typeof(HomeFolder));
                serializer.Serialize(writer, item);
            }
            else if (item is SystemDSN)
            {
                // backup ODBC DSN
                OS.OperatingSystem os = GetOS(item.ServiceId);

                // read DSN info
                SystemDSN itemDsn = item as SystemDSN;
                SystemDSN dsn = os.GetDSN(item.Name);
                dsn.DatabasePassword = itemDsn.DatabasePassword;

                XmlSerializer serializer = new XmlSerializer(typeof(SystemDSN));
                serializer.Serialize(writer, dsn);
            }

            return 0;
        }

        public int BackupItem(string tempFolder, XmlWriter writer, ServiceProviderItem item, ResourceGroupInfo group)
        {
            if (!(item is DnsZone))
                return 0;

            // DNS provider
            DNSServer dns = GetDNSServer(item.ServiceId);

            // zone records serialized
            XmlSerializer serializer = new XmlSerializer(typeof(DnsRecord));

            try
            {
                // get zone records
                DnsRecord[] records = dns.GetZoneRecords(item.Name);

                // serialize zone records
                foreach (DnsRecord record in records)
                    serializer.Serialize(writer, record);
            }
            catch (Exception ex)
            {
                TaskManager.WriteError(ex, "Could not read zone records");
            }

            return 0;
        }

        public override void ChangeServiceItemsState(ServiceProviderItem[] items, bool enabled)
        {

            foreach (ServiceProviderItem item in items)
            {
                try
                {
                    if (item is Organization)
                    {
                        Organization org = item as Organization;
                        ChangeOrganizationState(org, enabled);
                    }
                }
                catch (Exception ex)
                {
                    HostedSolutionLog.LogError(
                        String.Format("Error deleting '{0}' {1}", item.Name, item.GetType().Name), ex);
                }
            }
        }

 public override void DeleteServiceItems(ServiceProviderItem[] items)
 {
     foreach (ServiceProviderItem item in items)
     {
         if (item is StatsSite)
         {
             try
             {
                 DeleteSite(((StatsSite)item).SiteId);
             }
             catch (Exception ex)
             {
                 Log.WriteError(String.Format("Error deleting '{0}' {1}", item.Name, item.GetType().Name), ex);
             }
         }
     }
 }

 private static WebSite ConvertItemToWebSite(ServiceProviderItem item)
 {
     return (WebSite)item;
 }

 public override void DeleteServiceItems(ServiceProviderItem[] items)
 {
     foreach (ServiceProviderItem item in items)
     {
         if (item is VirtualMachine)
         {
             // delete virtual machine
             VirtualMachine vm = item as VirtualMachine;
             DeleteVirtualMachineServiceItem(vm);
         }
         else if (item is VirtualSwitch)
         {
             // delete switch
             VirtualSwitch vs = item as VirtualSwitch;
             DeleteVirtualSwitchServiceItem(vs);
         }
     }
 }

 public override void DeleteServiceItems(ServiceProviderItem[] items)
 {
     foreach (ServiceProviderItem item in items)
     {
         if (item is DnsZone)
         {
             try
             {
                 // delete DNS zone
                 DeleteZone(item.Name);
             }
             catch (Exception ex)
             {
                 Log.WriteError(String.Format("Error deleting '{0}' Power DNS zone", item.Name), ex);
             }
         }
     }
 }

 public override void ChangeServiceItemsState(ServiceProviderItem[] items, bool enabled)
 {
     foreach (ServiceProviderItem item in items)
     {
         if (item is VirtualMachine)
         {
             // start/stop virtual machine
             VirtualMachine vm = item as VirtualMachine;
             ChangeVirtualMachineServiceItemState(vm, enabled);
         }
     }
 }

		public override void DeleteServiceItems(ServiceProviderItem[] items)
		{
			foreach (ServiceProviderItem item in items)
			{
				if (item is FtpAccount)
				{
					try
					{
						// delete FTP account
						DeleteAccount(item.Name);
					}
					catch (Exception ex)
					{
						Log.WriteError(String.Format("Error deleting '{0}' {1}", item.Name, item.GetType().Name), ex);
					}
				}
			}
		}

		public override void ChangeServiceItemsState(ServiceProviderItem[] items, bool enabled)
		{
			foreach (ServiceProviderItem item in items)
			{
				if (item is FtpAccount)
				{
					try
					{
						// change FTP account state
						FtpAccount account = GetAccount(item.Name);
						account.Enabled = enabled;
						UpdateAccount(account);
					}
					catch (Exception ex)
					{
						Log.WriteError(String.Format("Error switching '{0}' {1}", item.Name, item.GetType().Name), ex);
					}
				}
			}
		}

 private static SharedSSLFolder ConvertItemToSharedSSLFolder(ServiceProviderItem item)
 {
     return (SharedSSLFolder)item;
 }

		public override void ChangeServiceItemsState(ServiceProviderItem[] items, bool enabled)
		{
			foreach (ServiceProviderItem item in items)
			{
				if (item is MailDomain)
				{
					try
					{
						// enable/disable mail domain
						if (DomainExists(item.Name))
						{
							MailDomain mailDomain = GetDomain(item.Name);
							mailDomain.Enabled = enabled;
							UpdateDomain(mailDomain);
						}
					}
					catch (Exception ex)
					{
						Log.WriteError(String.Format("Error switching '{0}' SmarterMail domain", item.Name), ex);
					}
				}
			}
		}

        public int BackupItem(string tempFolder, System.Xml.XmlWriter writer, ServiceProviderItem item, ResourceGroupInfo group)
        {
            if (item is WebSite)
            {
                WebServer web = GetWebServer(item.ServiceId);

                // read web site
                WebSite itemSite = item as WebSite;
                string siteId = itemSite.SiteId;
                WebSite site = web.GetSite(siteId);
                site.SiteId = itemSite.SiteId;
                site.SiteIPAddressId = itemSite.SiteIPAddressId;
                site.DataPath = itemSite.DataPath;
                site.FrontPageAccount = itemSite.FrontPageAccount;
                site.FrontPagePassword = itemSite.FrontPagePassword;

                // serialize web site
                XmlSerializer serializer = new XmlSerializer(typeof(WebSite));
                serializer.Serialize(writer, site);

                // process virtual directories
                WebVirtualDirectory[] vdirs = web.GetVirtualDirectories(siteId);
                foreach (WebVirtualDirectory vdirShort in vdirs)
                {
                    WebVirtualDirectory vdir = web.GetVirtualDirectory(siteId, vdirShort.Name);

                    // serialize vdir
                    serializer = new XmlSerializer(typeof(WebVirtualDirectory));
                    serializer.Serialize(writer, vdir);
                }
            }
            else if (item is SharedSSLFolder)
            {
                SharedSSLFolder sslFolder = GetSharedSSLFolder(item.Id);

                // convert content path to physical
                sslFolder.ContentPath = FilesController.GetFullPackagePath(item.PackageId, sslFolder.ContentPath);

                XmlSerializer serializer = new XmlSerializer(typeof(SharedSSLFolder));
                serializer.Serialize(writer, sslFolder);
            }

            return 0;
        }

		public override ServiceProviderItemDiskSpace[] GetServiceItemsDiskSpace(ServiceProviderItem[] items)
		{
			List<ServiceProviderItemDiskSpace> itemsDiskspace = new List<ServiceProviderItemDiskSpace>();

			// update items with diskspace
			foreach (ServiceProviderItem item in items)
			{
				if (item is MailAccount)
				{
					try
					{

						// get mailbox size
						string name = item.Name;

						// try to get SmarterMail postoffices path
						string poPath = DomainsPath;
						if (poPath == null)
							continue;

						string mailboxName = name.Substring(0, name.IndexOf("@"));
						string domainName = name.Substring(name.IndexOf("@") + 1);

						string mailboxPath = Path.Combine(DomainsPath, String.Format("{0}\\Users\\{1}", domainName, mailboxName));

						Log.WriteStart(String.Format("Calculating '{0}' folder size", mailboxPath));

						// calculate disk space
						ServiceProviderItemDiskSpace diskspace = new ServiceProviderItemDiskSpace();
						diskspace.ItemId = item.Id;
						//diskspace.DiskSpace = 0;
						diskspace.DiskSpace = FileUtils.CalculateFolderSize(mailboxPath);
						itemsDiskspace.Add(diskspace);
						Log.WriteEnd(String.Format("Calculating '{0}' folder size", mailboxPath));
					}
					catch (Exception ex)
					{
						Log.WriteError(ex);
					}
				}
			}
			return itemsDiskspace.ToArray();
		}