Падает веб-приложение с ошибкой "Задание не найдено"

<%@ WebService Language="c#" Class="AccountingCardManagementService" %>
 
[WebService(Namespace = "http://integro.ru/estate/")]
public class AccountingCardManagementService : Integro.InMeta.Web.WebService
{
    public const string AccountingCardTask = "AccountingCardTasks\\AccountingCardTasks.exe";
    public const string AcceptCardParameters = "Action=accept AppId={0} UserAccount={1} ProcessId={2}";
    public const string UnloadCardParameters = "Action=unload AppId={0} UserAccount={1} ComplexId={2} OutputDir=\"{3}\"";
    public const string UnloadCardsPath = "unloadcards";
 
    public AccountingCardManagementService()
    {
        Settings.Init(Session.Application);
    }
 
    [WebMethod]
    public string AcceptCard(string processId)
    {
        if ( !Security.CanExecute(new InMetaServerSession(Session), Operations.ВнесениеКартУчетаВБД) ) {
            throw new Exception("Нет прав на внесение карт учета в БД");
        }
        string parameters = string.Format(AcceptCardParameters,
            Session.Application.Id,
            Session.UserAccount,
            processId);
 
        return TaskProcessor.Start("AcceptAccountingCard", AccountingCardTask, parameters);
    }
 
    [WebMethod]
    public void DeleteProcess(string processId)
    {
        if(!Security.CanExecute(new InMetaServerSession(Session), Operations.УдалениеПроцессовПриемки)){
            throw new Exception("Нет прав на удаление процессов приемки");
        }
        DataObject process = Session["AccountingCard/AcceptanceProcess"].QueryObject("State", new DataId(processId));
        if ( process.GetInteger("State", 0) == 2 ) {
            throw new Exception("Процесс не может быть удален, так карта уже внесена в БД");
        }
        process.Delete();
        Session.Commit();
    }
 
    [WebMethod]
    public string UnloadCard(string complexId)
    {
        if ( !Security.CanExecute(new InMetaServerSession(Session), Operations.ВыгрузкаКартУчета) ) {
            throw new Exception("Нет прав на выгрузку карт учета");
        }
 
        if (!string.IsNullOrEmpty(complexId)) {
            InMetaServerSession session = new InMetaServerSession(Session);
 
            if (Settings.Customer == Customer.МЗИО) {
                //todo: исправить получение RegisteredSubject
                RegisteredSubject registeredSubject = session.Get<RegisteredSubject>(complexId);
                if (registeredSubject.IsTreasuryPropertyExists) {
                    if (registeredSubject.IsTreasury.HasValue && registeredSubject.IsTreasury.Value) {
                        if (!Security.CanExecute(new InMetaServerSession(Session), Operations.РедактированиеОбъектовКазны)) {
                            throw new Exception("Нет прав на выгрузку карт учета казны");
                        }
                    }
                    else {
                        if (!Security.CanExecute(new InMetaServerSession(Session), Operations.РедактированиеОбъектовРеестра)) {
                            throw new Exception("Нет прав на выгрузку карт учета реестра");
                        }
                    }
                }
            }
        }       
        
        string unloadCardPath = UnloadCardsPath;        
        string parameters = string.Format(UnloadCardParameters,
            Session.Application.Id,
            Session.UserAccount,
            complexId,
            Server.MapPath(unloadCardPath));
 
        return TaskProcessor.Start("UnloadAccountingCard", AccountingCardTask, parameters);
    }
 
    [WebMethod]
    public void DeleteUnloadProcess(string processId)
    {
        if ( !Security.CanExecute(new InMetaServerSession(Session), Operations.УдалениеПроцессовВыгрузки) ) {
            throw new Exception("Нет прав на удаление процессов выгрузки");
        }
        Session["AccountingCard/UnloadProcess"][processId].Delete();
        Session.Commit();
    }
 
    [WebMethod]
    public string ReportRegisteredObjects(string RegisterNo, string Name, string HolderRegisterNo, string HolderName, string HolderInn, string Region,
        string SubRgn, string Locality, string Street, string House, string Building, string Description, string Comment) {
 
        InMetaServerSession inmetaSession = new InMetaServerSession(Session);
        Org registrHostOrg = inmetaSession.Get<Org>(Settings.RegistrHostOrgId.ToString());
        RegisteredObjectSearch search = new RegisteredObjectSearch(inmetaSession);
        search.ActualDate = DateTime.Now;
        search.RegisterNo = RegisterNo;
        search.Name = Name;
        search.HolderRegisterNo = HolderRegisterNo;
        search.HolderName = HolderName;
        search.Region = Region;
        search.SubRgn = SubRgn;
        search.Locality = Locality;
        search.Street = Street;
        search.House = House;
        search.Building = Building;
        search.Description = Description;
        search.Comment = Comment;
 
        List<RegisteredObject> registeredObjects = search.Search();
 
        ExcelTable table = new ExcelTable();
        table.Styles.Add(ExcelStyle.Header);
 
        ExcelRow header = table.Rows.Add();
        header.Style = ExcelStyle.Header;
 
        header.Cells.Add("Вид");
        header.Cells.Add("Учетный номер");
        header.Cells.Add("Наименование");
        header.Cells.Add("Адрес");
        header.Cells.Add("Балансодержатель");
        header.Cells.Add("Реестровый номер балансодержателя");
        header.Cells.Add("Площадь");
        header.Cells.Add("Этажность");
        header.Cells.Add("Примечание");
        
        foreach ( RegisteredObject registeredObject in registeredObjects ) {
            ExcelRow row = table.Rows.Add();
            row.Cells.Add(registeredObject.Kind);
            row.Cells.Add(registeredObject.RegisterNo);
            row.Cells.Add(registeredObject.NameView);
            row.Cells.Add(registeredObject.Address);
            Law mainLaw = registeredObject.GetMainLaw(registrHostOrg, DateTime.Now, Settings.LawKindIds.PropertyLawKinds);
            RegisteredSubject balanceHolder = registeredObject.GetFirstBalanceHolder(mainLaw, DateTime.Now, Settings.LawKindIds.BalanceLawKinds);
            
            row.Cells.Add(InMetaObjectUtils.Assigned(balanceHolder)? balanceHolder.Name: "Казна");
            row.Cells.Add(InMetaObjectUtils.Assigned(balanceHolder) ? balanceHolder.RegisterNo : "Казна");
            row.Cells.Add(registeredObject.Area);
            row.Cells.Add(registeredObject.FloorCount);
            row.Cells.Add(registeredObject.Comment);
        }
 
        return table.ToXml();
    }
    
    private XmlDocument GenerateError(string errorMessage, string errorDetails)
    {
            XmlDocument doc = XmlUtils.CreateDocument("task");
            XmlElement taskElem = doc.DocumentElement;
            XmlUtils.SetChildText(taskElem, "state", "error");
            XmlUtils.SetChildText(taskElem, "errorMessage", errorMessage);
            XmlUtils.SetChildText(taskElem, "errorDetails", errorDetails);          
            return doc;
    }
 
    private XmlDocument GenerateProgress(string message, int progressCount, int progressPosition)
    {
            XmlDocument doc = XmlUtils.CreateDocument("task");
            XmlElement taskElem = doc.DocumentElement;
            XmlUtils.SetChildText(taskElem, "state", "running");
            XmlUtils.SetChildText(taskElem, "message", message);
            XmlUtils.SetChildText(taskElem, "progressCount", progressCount.ToString());
            XmlUtils.SetChildText(taskElem, "progressPosition", progressPosition.ToString());           
            return doc;
    }
 
    private XmlDocument GenerateComplete(string message)
    {
            XmlDocument doc = XmlUtils.CreateDocument("task");
            XmlElement taskElem = doc.DocumentElement;
            XmlUtils.SetChildText(taskElem, "state", "complete");
            XmlUtils.SetChildText(taskElem, "message", message);            
            return doc;      
    }
 
    [WebMethod]
    public XmlDocument GetTaskStatus(string taskId)
    {
        Task task = TaskProcessor.Find(taskId);
 
        if ( task == null ) {
            return GenerateError("Задание не найдено. taskId:"+taskId, null);
        }
 
        switch ( task.State ) {
            case TaskState.Running:
                string message = string.Empty;
                int progressCount = 0, progressPosition = 0;
                foreach ( TaskExecution execution in task.Executions ) {
                    message += "\r\n" + execution.Message;
                    progressCount = execution.ProgressCount;
                    progressPosition = execution.ProgressPosition;
                }
                return GenerateProgress(message, progressCount, progressPosition);
            case TaskState.Complete:
                TaskProcessor.Cancel(taskId);
                return GenerateComplete("Завершено");
            case TaskState.Error:
                TaskProcessor.Cancel(taskId);
                if ( task.Error is AccountingCardClasses.ApplicationException ) {
                    return GenerateError(task.Error.Message, null);
                }
                return GenerateError(task.Error.Message, task.Error.ToString());
            default:
                return GenerateError("Неизвестное состояние задания", null);
        }
    }
}

using Integro.InMeta.Runtime;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Threading;
using System.Xml;
 
namespace TaskProcesses
{
  public class TaskProcessor : IDisposable
  {
    private FileStream m_indexFile;
    public readonly XmlDocument Document;
    private static string communicationFolder;
 
    public XmlElement Root
    {
      get
      {
        return this.Document.DocumentElement;
      }
    }
 
    private static string CommunicationFolder
    {
      get
      {
        if (TaskProcessor.communicationFolder == null)
          TaskProcessor.communicationFolder = Path.Combine(DataApplication.get_InMetaInstallPath(), "Tasks");
        return TaskProcessor.communicationFolder;
      }
    }
 
    private TaskProcessor(FileStream indexFile, XmlDocument document)
    {
      this.m_indexFile = indexFile;
      this.Document = document;
    }
 
    public void Dispose()
    {
      this.Close();
    }
 
    private void Close()
    {
      if (this.m_indexFile == null)
        return;
      this.m_indexFile.SetLength(0L);
      this.Document.Save((Stream) this.m_indexFile);
      this.m_indexFile.Close();
      this.m_indexFile = (FileStream) null;
    }
 
    private string GenerateNewTaskId()
    {
      string attribute = this.Root.GetAttribute("nextId");
      int num = string.IsNullOrEmpty(attribute) ? 1 : int.Parse(attribute);
      this.Root.SetAttribute("nextId", (num + 1).ToString());
      return num.ToString();
    }
 
    private string AddNewTask(string taskName)
    {
      string newTaskId = this.GenerateNewTaskId();
      XmlElement element = this.Document.CreateElement("task");
      this.SaveTask(element, new Task(taskName, newTaskId, TaskState.Running, DateTime.Now, new TaskExecution[0], (Exception) null));
      this.Root.AppendChild((XmlNode) element);
      return newTaskId;
    }
 
    private void SaveTask(XmlElement taskElement, Task task)
    {
      if (!string.IsNullOrEmpty(task.Name))
        taskElement.SetAttribute("name", task.Name);
      taskElement.SetAttribute("id", task.Id);
      taskElement.SetAttribute("state", task.State.ToString());
      taskElement.SetAttribute("lastUpdateTime", XmlConvert.ToString(task.LastUpdateTime, XmlDateTimeSerializationMode.Local));
      foreach (XmlElement selectNode in taskElement.SelectNodes("execution"))
        taskElement.RemoveChild((XmlNode) selectNode);
      foreach (TaskExecution execution in task.Executions)
      {
        XmlElement element = taskElement.OwnerDocument.CreateElement("execution");
        TaskProcessor.SaveExecution(element, execution);
        taskElement.AppendChild((XmlNode) element);
      }
      foreach (XmlElement selectNode in taskElement.SelectNodes("error"))
        taskElement.RemoveChild((XmlNode) selectNode);
      if (task.Error == null)
        return;
      XmlElement element1 = taskElement.OwnerDocument.CreateElement("error");
      this.SaveError(element1, task.Error);
      taskElement.AppendChild((XmlNode) element1);
    }
 
    private void SaveError(XmlElement element, Exception error)
    {
      XmlElement element1 = element.OwnerDocument.CreateElement("message");
      element1.InnerText = error.Message;
      element.AppendChild((XmlNode) element1);
      XmlElement element2 = element.OwnerDocument.CreateElement("details");
      element2.InnerText = error.ToString();
      element.AppendChild((XmlNode) element2);
      string str = (string) null;
      try
      {
        str = Utils.Serialize((object) error);
      }
      catch (Exception ex)
      {
        XmlElement element3 = element.OwnerDocument.CreateElement("serializationError");
        element3.InnerText = ex.ToString();
        element.AppendChild((XmlNode) element3);
      }
      if (string.IsNullOrEmpty(str))
        return;
      XmlElement element4 = element.OwnerDocument.CreateElement("data");
      element4.InnerText = str;
      element.AppendChild((XmlNode) element4);
    }
 
    private static void SaveExecution(XmlElement element, TaskExecution execution)
    {
      element.SetAttribute("message", execution.Message);
      element.SetAttribute("progressCount", execution.ProgressCount.ToString());
      element.SetAttribute("progressPosition", execution.ProgressPosition.ToString());
    }
 
    public void RemoveTask(string taskId)
    {
      XmlNode oldChild = this.Root.SelectSingleNode("task[@id='" + taskId + "']");
      if (oldChild == null)
        return;
      this.Root.RemoveChild(oldChild);
    }
 
    public static bool UpdateTask(Task task)
    {
      using (TaskProcessor taskProcessor = TaskProcessor.Open())
      {
        XmlElement taskElement = (XmlElement) taskProcessor.Root.SelectSingleNode("task[@id='" + task.Id + "']");
        if (taskElement == null)
          return false;
        taskProcessor.SaveTask(taskElement, task);
        return true;
      }
    }
 
    private static TaskProcessor Open()
    {
      string path = Path.Combine(TaskProcessor.CommunicationFolder, "tasks.xml");
      DateTime dateTime = DateTime.Now + TimeSpan.FromSeconds(1.0);
      FileStream indexFile = (FileStream) null;
      do
      {
        try
        {
          indexFile = File.Open(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
        }
        catch
        {
          if (DateTime.Now > dateTime)
            throw;
          else
            Thread.Sleep(1);
        }
      }
      while (indexFile == null);
      try
      {
        XmlDocument document = new XmlDocument();
        if (indexFile.Length == 0L)
        {
          document.AppendChild((XmlNode) document.CreateElement("tasks"));
        }
        else
        {
          document.Load((Stream) indexFile);
          foreach (XmlElement selectNode in document.DocumentElement.SelectNodes("task"))
          {
            if (DateTime.Now - XmlConvert.ToDateTime(selectNode.GetAttribute("lastUpdateTime"), XmlDateTimeSerializationMode.Local) > TimeSpan.FromDays(1.0))
              document.DocumentElement.RemoveChild((XmlNode) selectNode);
          }
        }
        return new TaskProcessor(indexFile, document);
      }
      catch
      {
        indexFile.Close();
        throw;
      }
    }
 
    public static Task[] GetAll()
    {
      List<Task> taskList = new List<Task>();
      using (TaskProcessor taskProcessor = TaskProcessor.Open())
      {
        foreach (XmlElement selectNode in taskProcessor.Root.SelectNodes("task"))
          taskList.Add(TaskProcessor.LoadTask(selectNode));
      }
      return taskList.ToArray();
    }
 
    private static Task LoadTask(XmlElement element)
    {
      List<TaskExecution> taskExecutionList = new List<TaskExecution>();
      foreach (XmlElement selectNode in element.SelectNodes("execution"))
        taskExecutionList.Add(TaskProcessor.LoadExecution(selectNode));
      TaskState state = (TaskState) Enum.Parse(typeof (TaskState), element.GetAttribute("state"), true);
      string attribute1 = element.GetAttribute("name");
      string attribute2 = element.GetAttribute("id");
      DateTime dateTime = XmlConvert.ToDateTime(element.GetAttribute("lastUpdateTime"), XmlDateTimeSerializationMode.Local);
      XmlElement errorElement = (XmlElement) element.SelectSingleNode("error");
      Exception error = (Exception) null;
      if (errorElement != null)
        error = TaskProcessor.LoadError(errorElement);
      return new Task(attribute1, attribute2, state, dateTime, taskExecutionList.ToArray(), error);
    }
 
    private static Exception LoadError(XmlElement errorElement)
    {
      XmlNode xmlNode = errorElement.SelectSingleNode("data");
      if (xmlNode != null)
      {
        try
        {
          return (Exception) Utils.Deserialize(xmlNode.InnerText);
        }
        catch
        {
        }
      }
      return (Exception) new TaskException(errorElement.SelectSingleNode("message").InnerText, errorElement.SelectSingleNode("details").InnerText);
    }
 
    private static TaskExecution LoadExecution(XmlElement element)
    {
      return new TaskExecution(element.GetAttribute("message"), XmlConvert.ToInt32(element.GetAttribute("progressCount")), XmlConvert.ToInt32(element.GetAttribute("progressPosition")));
    }
 
    public static string Start(string taskName, string filename, string parameters)
    {
      string str;
      using (TaskProcessor taskProcessor = TaskProcessor.Open())
        str = taskProcessor.AddNewTask(taskName);
      Process.Start(Path.Combine(Path.Combine(TaskProcessor.CommunicationFolder, "Bin"), filename), parameters + " TaskId=" + str);
      return str;
    }
 
    public static string StartAndWait(string taskName, string filename, string parameters)
    {
      string str;
      using (TaskProcessor taskProcessor = TaskProcessor.Open())
        str = taskProcessor.AddNewTask(taskName);
      Process.Start(Path.Combine(Path.Combine(TaskProcessor.CommunicationFolder, "Bin"), filename), parameters + " TaskId=" + str).WaitForExit();
      return str;
    }
 
    public static string Start(string filename, string parameters)
    {
      return TaskProcessor.Start((string) null, filename, parameters);
    }
 
    public static void Cancel(string taskId)
    {
      using (TaskProcessor taskProcessor = TaskProcessor.Open())
        taskProcessor.RemoveTask(taskId);
    }
 
    public static Task Find(string taskId)
    {
      foreach (Task task in TaskProcessor.GetAll())
      {
        if (task.Id == taskId)
          return task;
      }
      return (Task) null;
    }
 
    public static Task[] FindRunning(string taskName)
    {
      List<Task> taskList = new List<Task>();
      foreach (Task task in TaskProcessor.GetAll())
      {
        if (task.Name == taskName && task.State == TaskState.Running)
          taskList.Add(task);
      }
      return taskList.ToArray();
    }
  }
}