public ActionResult ReanalyzeAllItems(Nullable <int> informationTypeID)
        {
            List <InputDTO> inputMessages = null;

            if (informationTypeID.HasValue)
            {
                InformationTypeDTO informationType = InformationTypeDAC.GetInformationType(informationTypeID.Value, ContextManager.Current.SelectedAreaID.Value);
                if (informationType.Title == "Unknown")
                {
                    inputMessages = InputDAC.GetFilteredInputMessages(informationTypeID.Value, ContextManager.Current.SelectedAreaID.Value, Membership.GetUser().Email);
                }
                else
                {
                    inputMessages = InputDAC.GetInputMessages(informationTypeID.Value, ContextManager.Current.SelectedAreaID.Value, 0);
                }
            }
            else
            {
                inputMessages = InputDAC.GetInputMessages(ContextManager.Current.SelectedAreaID.Value, 100000);
            }

            if (inputMessages != null)
            {
                foreach (InputDTO inputMessage in inputMessages)
                {
                    Analyzer.RerunAnalysis(inputMessage.ID.Value, ContextManager.Current.SelectedAreaID.Value);
                }
            }

            return(Index(informationTypeID));
        }
 public ActionResult Index(Nullable <int> id)
 {
     if (id.HasValue)
     {
         List <InputDTO>    inputMessages   = new List <InputDTO>();
         InformationTypeDTO informationType = InformationTypeDAC.GetInformationType(id.Value, ContextManager.Current.SelectedAreaID.Value);
         if (informationType.Title == "Unknown") // id.Value == 203)
         {
             inputMessages = InputDAC.GetFilteredInputMessages(id.Value, ContextManager.Current.SelectedAreaID.Value, Membership.GetUser().Email);
         }
         else
         {
             inputMessages = InputDAC.GetInputMessages(id.Value, ContextManager.Current.SelectedAreaID.Value, 0);
         }
         return(View("Index", new InputIndexModel()
         {
             InputMessages = inputMessages, InformationType = InformationTypeDAC.GetInformationType(id.Value, ContextManager.Current.SelectedAreaID.Value)
         }));
     }
     else
     {
         return(View("Index", new InputIndexModel()
         {
             InputMessages = InputDAC.GetInputMessages(ContextManager.Current.SelectedAreaID.Value, 50)
         }));
     }
 }
Beispiel #3
0
        public static List <AnalysisResultDTO> RerunAnalysis(int analysisInputID, Int32 areaID)
        {
            String text = InputDAC.GetInputMessage(analysisInputID).TextInput;

            InputDAC.DeleteWordHeaders(analysisInputID);
            AnalysisDAC.StoreWordHeaders(text, analysisInputID);             // This section could be taken out in time
            return(GetAnalysisResults(analysisInputID, areaID, text));
        }
        public ActionResult ShowAttachment(int id)
        {
            //List<AttachmentDTO> attachments = InputDAC.GetAttachments(216);
            //MemoryStream ms = new MemoryStream(attachments[0].BinaryData);
            AttachmentDTO attachment = InputDAC.GetAttachment(id);
            MemoryStream  ms         = new MemoryStream(attachment.BinaryData);

            return(new ImageResult(ms, FileTypeHelper.GetContentType(attachment.Filename)));
        }
 public ActionResult Details(Int32 id)
 {
     //ResultDAC.UpdateReadStatus(id, true);
     return(View(new InputDetailsModel()
     {
         InputMetaDataList = InputDAC.GetMetaDataList(id),
         InputMessage = InputDAC.GetInputMessage(id),
     }));
 }
        public ActionResult Details(Int32 id)
        {
            ResultDAC.UpdateReadStatus(id, true);
            AnalysisResultDTO result = ResultDAC.GetResult(id);

            return(View(new InputDetailsModel()
            {
                InputMetaDataList = InputDAC.GetMetaDataList(result.AnalysisInputID),
                InputMessage = InputDAC.GetInputMessage(result.AnalysisInputID),
                AnalysisResult = result
            }));
        }
        public ActionResult Move(Nullable <Int32> informationTypeID, IList <SelectListItem> CheckedList)
        {
            /* Remove the ones with no value, as these are not checked - MRS */
            CheckedList = CheckedList.Where(a => a.Value != null).ToList <SelectListItem>();

            /* Move these */

            if (informationTypeID.HasValue)
            {
                return(View("InputListControl", new InputIndexModel()
                {
                    InputMessages = InputDAC.GetInputMessages(informationTypeID.Value, ContextManager.Current.SelectedAreaID.Value, 0)
                }));
            }
            else
            {
                return(View("InputListControl", new InputIndexModel()
                {
                    InputMessages = InputDAC.GetInputMessages(ContextManager.Current.SelectedAreaID.Value, 50)
                }));
            }
        }
        public ActionResult Search(String searchText, Nullable <Int32> informationTypeID, String msgAmount)
        {
            Int32 msgAmountInt;

            if (!Int32.TryParse(msgAmount, out msgAmountInt))
            {
                msgAmountInt = 50;
            }
            if (informationTypeID.HasValue)
            {
                return(View("InputListControl", new InputIndexModel()
                {
                    InputMessages = InputDAC.GetInputMessages(ContextManager.Current.SelectedAreaID.Value, informationTypeID.Value, searchText, msgAmountInt)
                }));
            }
            else
            {
                return(View("InputListControl", new InputIndexModel()
                {
                    InputMessages = InputDAC.GetInputMessages(ContextManager.Current.SelectedAreaID.Value, searchText, msgAmountInt)
                }));
            }
        }
Beispiel #9
0
        private static void FindAndStoreAttachments(XmlDocument xDoc, Int32 analysisInputID)
        {
            //XmlNodeList attachmentNodeList = xDoc.SelectNodes("IFlowMessageDTO/Attachments/Attachment");
            XmlNodeList attachmentNodeList = xDoc.SelectNodes("incomingMail/attachments/attachment");

            foreach (XmlNode attachmentNode in attachmentNodeList)
            {
                String contentAsBase64 = attachmentNode.InnerText;
                String path            = attachmentNode.Attributes["filename"].InnerText;
                String ext             = Path.GetExtension(path);
                String title           = Path.GetFileName(path);
                //String title = attachmentNode.SelectSingleNode("title").InnerText;
                //String ext = attachmentNode.SelectSingleNode("extension").InnerText;
                //String contentAsBase64 = attachmentNode.SelectSingleNode("content").InnerText;

                InputDAC.StoreAttachment(new AttachmentDTO
                {
                    AnalysisInputID = analysisInputID,
                    Title           = title,
                    Filename        = title + "." + ext,
                    BinaryData      = Convert.FromBase64String(contentAsBase64)
                });
            }
        }
 public ActionResult AttachmentListControl(InputDetailsModel model)
 {
     model.Attachments = InputDAC.GetAttachments(model.InputMessage.ID.Value);
     return(View("AttachmentListControl", model));
 }
Beispiel #11
0
        public static List <AnalysisResultDTO> AnalyzeText(String xml)
        {
            try
            {
                //EventLog.WriteEntry("iHedge Services", "AnalyzeText");
                XmlDocument xDoc = new XmlDocument();
                xDoc.LoadXml(xml);

                try
                {
                    String type = xDoc.SelectSingleNode("incomingMail/content/").Attributes["type"].Value;

                    /*if(!String.IsNullOrEmpty(type))
                     * {
                     *  type = type.ToLower();
                     *  type = type.Substring(type.IndexOf("charset")+7);
                     *  if(type.IndexOf(";"))
                     *
                     * }*/
                }
                catch (Exception ex)
                {
                }

                String base64Content = xDoc.SelectSingleNode("incomingMail/content").InnerText;
                byte[] contentBytes  = Convert.FromBase64String(base64Content);
                String content       = Encoding.GetEncoding("ISO-8859-1").GetString(contentBytes);

                Dictionary <String, String> metaValues = ExtractInputMetaData(xDoc);//Emailfolder
                //throw new Exception("Step 2");
                //TEMPORARY
                if (content.Contains("PULL = "))
                {
                    string text = content.Substring(content.IndexOf("PULL = ") + 7, content.IndexOf("PULLEND") - content.IndexOf("PULL = ") - 8);
                    metaValues.Add("owner", text);
                }
                //TEMP-end
                Int32 areaID          = GetDefaultAreaID(metaValues);
                Int32 analysisInputID = InputDAC.StoreTextInput(content, areaID);

                foreach (KeyValuePair <String, String> metaItem in metaValues)
                {
                    InputDAC.StoreMetaData(new InputMetaDataDTO
                    {
                        InputID   = analysisInputID,
                        Title     = metaItem.Key,
                        MetaValue = metaItem.Value
                    });
                }

                //throw new Exception("Step 3");
                FindAndStoreAttachments(xDoc, analysisInputID);

                AnalysisDAC.StoreWordHeaders(content, analysisInputID);
                //throw new Exception("Step 4");
                return(GetAnalysisResults(analysisInputID, areaID, content));
            }
            catch (Exception ex)
            {
                throw new Exception("XML = [" + xml + "]\r\n" + ex.Message + "\r\n" + ex.StackTrace);
            }
        }