示例#1
0
        public ActionResult EditEmailParsingUpdatingRule(Oasis.Models.EditUpdatingRuleForEmailModel model)
        {
            if (ModelState.IsValid)
            {
                var table = tablesRepository.Find(t => t.AuthorId_Id == demoHelper.userId && t.Name.Equals(model.UpdatingRule.Cell.TableId));

                var updatingRule = demoHelper.dataRules.Find(w => w.Id == model.UpdatingRule.Id);

                if (model.UpdatingRule.Id != 0 && updatingRule != null)
                {
                    updatingRule.Expression = HttpUtility.HtmlEncode(model.UpdatingRule.Expression);
                    updatingRule.IsRegexpExpression = model.UpdatingRule.IsRegexpExpression.Equals(CultureHelper.GetStringForCurentCulture("RegularExpression"));
                    updatingRule.DataExploration = (int)Enum.Parse(typeof(DataExplorationEnums), model.UpdatingRule.DataExploration);
                    updatingRule.DataExplorationExpression = HttpUtility.HtmlEncode(model.UpdatingRule.DataExplorationExpression);
                    updatingRule.IsChanging = model.UpdatingRule.IsChanging.Equals("C");
                    updatingRule.ExpressionToChange = HttpUtility.HtmlEncode(model.UpdatingRule.ExpressionToChange);
                    updatingRule.RegularExpressionToChange = HttpUtility.HtmlEncode(model.UpdatingRule.RegularExpressionToChange);
                    updatingRule.ChangeTo = HttpUtility.HtmlEncode(model.UpdatingRule.ChangeTo);
                    updatingRule.IsUpdatindIndex = true;
                    updatingRule.ParsingMode = model.UpdatingRule.ParsingMode;
                    updatingRule.ConsiderRegister = model.UpdatingRule.ConsiderRegister.Equals("C");
                    updatingRule.Status = model.UpdatingRule.Status;
                    updatingRule.EmailParsingRulesModelsId_Id = model.Id;
                    updatingRule.IsUpdatingRule = false;
                    updatingRule.ColumnForUpdate = (int)Enum.Parse(typeof(ColumnEnums), model.UpdatingRule.ColumnForUpdate);
                }
                else
                {
                    demoHelper.dataRules.Add(new Model.EmailDataParsingRulesModels
                    {
                        Expression = HttpUtility.HtmlEncode(model.UpdatingRule.Expression),
                        IsRegexpExpression = model.UpdatingRule.IsRegexpExpression.Equals(CultureHelper.GetStringForCurentCulture("RegularExpression")),
                        DataExploration = (int)Enum.Parse(typeof(DataExplorationEnums), model.UpdatingRule.DataExploration),
                        DataExplorationExpression = HttpUtility.HtmlEncode(model.UpdatingRule.DataExplorationExpression),
                        IsChanging = model.UpdatingRule.IsChanging.Equals("C"),
                        ExpressionToChange = HttpUtility.HtmlEncode(model.UpdatingRule.ExpressionToChange),
                        RegularExpressionToChange = HttpUtility.HtmlEncode(model.UpdatingRule.RegularExpressionToChange),
                        ChangeTo = HttpUtility.HtmlEncode(model.UpdatingRule.ChangeTo),
                        EmailParsingRulesModelsId_Id = model.Id,
                        IsUpdatindIndex = true
                    });
                }
                var rule = demoHelper.rules.Find(w => w.Id == model.Id);

                bool isUpdatingRule = true;

                List<SelectListItem> saveEmail = new List<SelectListItem>
                {
                    new SelectListItem {Text = "Email without attachments", Value = "0"},
                    new SelectListItem {Text = "Email with attachments", Value = "1"}
                };

                if (model.SaveEmailProperties != null)
                {
                    if (model.SaveEmailProperties.Count > 0)
                    {
                        foreach (var saveEmailProp in model.SaveEmailProperties)
                        {
                            var saveProp = demoHelper.allSaveEmailProperties.Find(w => w.Id == saveEmailProp.Id);
                            if (saveProp != null && saveProp.DefaultValue != null)
                            {
                                saveProp.TableId = saveEmailProp.TableId;
                                saveProp.Worksheet = saveEmailProp.Worksheet;
                                saveProp.Column = saveEmailProp.Column;
                                saveProp.DefaultValue = saveEmailProp.DefaultValue;
                            }
                            else if (saveEmailProp.Id == 0 && saveEmailProp.DefaultValue != null)
                            {
                                demoHelper.allSaveEmailProperties.Add(new Model.SaveEmailProperty()
                                {
                                    TableId = saveEmailProp.TableId,
                                    Worksheet = saveEmailProp.Worksheet,
                                    Column = saveEmailProp.Column,
                                    DefaultValue = saveEmailProp.DefaultValue,
                                    EmailParsingRulesModelsId = saveEmailProp.EmailParsingRulesModelsId
                                });
                            }
                        }
                    }
                }
                if (rule != null)
                {
                    rule.AuthorId_Id = demoHelper.userId;
                    rule.Email = HttpUtility.HtmlEncode(model.Email);
                    rule.Subject = HttpUtility.HtmlEncode(model.Subject);
                    rule.PlainContains = HttpUtility.HtmlEncode(model.PlainContains);
                    rule.IsUpdatingRule = isUpdatingRule;
                    rule.Status = Model.Enums.RuleStatusEnums.Active.ToString();

                    return RedirectToAction("EditEmailParsingRule", new { ruleId = rule.Id });
                }
            }

            return View();
        }
示例#2
0
        public ActionResult EditEmailParsingRule(Oasis.Models.EditRuleForEmailModel model)
        {
            if (ModelState.IsValid)
            {
                var rule = demoHelper.rules.Find(w => w.Id == model.Id);

                bool isUpdatingRule = model.IsUpdatingRule.Equals("C");

                List<SelectListItem> saveEmail = new List<SelectListItem>
                {
                    new SelectListItem {Text = "Email without attachments", Value = "0"},
                    new SelectListItem {Text = "Email with attachments", Value = "1"}
                };
                if (model.SaveEmailProperties != null)
                {
                    if (model.SaveEmailProperties.Count > 0)
                    {
                        foreach (var saveEmailProp in model.SaveEmailProperties)
                        {
                            var saveProp = demoHelper.allSaveEmailProperties.Find(w => w.Id == saveEmailProp.Id);
                            if (saveProp != null && saveProp.SaveEmailProp != null)
                            {
                                saveProp.TableId = saveEmailProp.TableId;
                                saveProp.Worksheet = saveEmailProp.Worksheet;
                                saveProp.Column = saveEmailProp.Column;
                                saveProp.SaveEmailProp = saveEmail.Find(w => w.Text == saveEmailProp.SaveEmailProp).Value;
                            }
                            else if (saveProp != null && saveProp.DefaultValue != null)
                            {
                                saveProp.TableId = saveEmailProp.TableId;
                                saveProp.Worksheet = saveEmailProp.Worksheet;
                                saveProp.Column = saveEmailProp.Column;
                                saveProp.DefaultValue = saveEmailProp.DefaultValue;
                            }
                            else if (saveEmailProp.Id == 0 && saveEmailProp.SaveEmailProp != null)
                            {
                                demoHelper.allSaveEmailProperties.Add(new Model.SaveEmailProperty()
                                {
                                    TableId = saveEmailProp.TableId,
                                    Worksheet = saveEmailProp.Worksheet,
                                    Column = saveEmailProp.Column,
                                    SaveEmailProp = saveEmailProp.SaveEmailProp,
                                    EmailParsingRulesModelsId = saveEmailProp.EmailParsingRulesModelsId
                                });
                            }
                            else if (saveEmailProp.Id == 0 && saveEmailProp.DefaultValue != null)
                            {
                                demoHelper.allSaveEmailProperties.Add(new Model.SaveEmailProperty()
                                {
                                    TableId = saveEmailProp.TableId,
                                    Worksheet = saveEmailProp.Worksheet,
                                    Column = saveEmailProp.Column,
                                    DefaultValue = saveEmailProp.DefaultValue,
                                    EmailParsingRulesModelsId = saveEmailProp.EmailParsingRulesModelsId
                                });
                            }
                        }
                    }
                }
                if (rule != null)
                {
                    rule.AuthorId_Id = demoHelper.userId;
                    rule.Email = HttpUtility.HtmlEncode(model.Email);
                    rule.Subject = HttpUtility.HtmlEncode(model.Subject);
                    rule.PlainContains = HttpUtility.HtmlEncode(model.PlainContains);
                    rule.IsUpdatingRule = isUpdatingRule;
                    rule.Status = Model.Enums.RuleStatusEnums.Active.ToString();
                    rule.CopyRuleFromPreviousOrder = model.CopyRuleFromPreviousOrder.Equals("C");

                    return RedirectToAction("EditEmailParsingRule", new { ruleId = rule.Id });
                }
            }
            return View();
        }
示例#3
0
        public long AddEmptySaveEmailProperty(Oasis.Models.EditRuleForEmailModel model)
        {
            var tables = tablesRepository.FindAll(w => w.AspNetUsers.Id.Equals(demoHelper.userId)).Select(l => l.Name).ToList();

                var rule = emailParsingRulesRepository.Find(w => w.Id == model.Id);

                long spreadsheetId = ParseHelper.GetSpreadsheetIdByName(demoHelper.userId, model.TableId);

                List<SelectListItem> saveEmail = new List<SelectListItem>
                {
                    new SelectListItem {Text = "Email without attachments", Value = "0"},
                    new SelectListItem {Text = "Email with attachments", Value = "1"}
                };

                if (rule != null)
                {
                    rule.AuthorId_Id = demoHelper.userId;
                    rule.Email = HttpUtility.HtmlEncode(model.Email);
                    rule.Subject = HttpUtility.HtmlEncode(model.Subject);
                    rule.PlainContains = HttpUtility.HtmlEncode(model.PlainContains);
                    //rule.IsUpdatingRule = isUpdatingRule;
                    rule.Status = Model.Enums.RuleStatusEnums.Active.ToString();
                    rule.TableId = spreadsheetId;

                    List<SaveEmailProperty> saveEmailProperties = new List<SaveEmailProperty>();

                    if(model.SaveEmailProperties != null)
                    {
                        saveEmailProperties = model.SaveEmailProperties.Where(w => w.SaveEmailProp != null).ToList();
                    }

                    if (saveEmailProperties.Count == 0)
                    {
                        demoHelper.allSaveEmailProperties.Add(new Model.SaveEmailProperty()
                        {
                            TableId = tables[0],
                            Worksheet = "0",
                            Column = "A",
                            SaveEmailProp = saveEmail[0].Value,
                            EmailParsingRulesModelsId = rule.Id
                        });
                    }
                    else if (saveEmailProperties.Count > 0 && saveEmailProperties.First().Id == 0)
                    {
                        demoHelper.allSaveEmailProperties.Add(new Model.SaveEmailProperty()
                        {
                            TableId = model.SaveEmailProperties.First().TableId,
                            Worksheet = model.SaveEmailProperties.First().Worksheet,
                            Column = model.SaveEmailProperties.First().Column,
                            SaveEmailProp = saveEmail.Find(w => w.Text == model.SaveEmailProperties.First().SaveEmailProp).Value,
                            EmailParsingRulesModelsId = rule.Id
                        });
                        demoHelper.allSaveEmailProperties.Add(new Model.SaveEmailProperty()
                        {
                            TableId = tables[0],
                            Worksheet = "0",
                            Column = "A",
                            SaveEmailProp = saveEmail[0].Value,
                            EmailParsingRulesModelsId = rule.Id
                        });
                    }
                    else
                    {
                        foreach (var saveEmailProp in saveEmailProperties)
                        {
                            var saveProp = demoHelper.allSaveEmailProperties.Find(w => w.Id == saveEmailProp.Id);
                            saveProp.TableId = saveEmailProp.TableId;
                            saveProp.Worksheet = saveEmailProp.Worksheet;
                            saveProp.Column = saveEmailProp.Column;
                            saveProp.SaveEmailProp = saveEmail.Find(w => w.Text == saveEmailProp.SaveEmailProp).Value;
                        }
                        demoHelper.allSaveEmailProperties.Add(new Model.SaveEmailProperty()
                        {
                            TableId = tables[0],
                            Worksheet = "0",
                            Column = "A",
                            SaveEmailProp = saveEmail[0].Value,
                            EmailParsingRulesModelsId = rule.Id
                        });
                    }

                    return rule.Id;
                    // return RedirectToAction("AddNewDataRuleForEmails", new { ruleId = rule.Id });
                }
                return 0;
        }
示例#4
0
        public ActionResult EditEmailDataParsingRule(Oasis.Models.EditRuleForDataModel model)
        {
            if (ModelState.IsValid)
            {
                var table = tablesRepository.Find(t => t.AuthorId_Id == demoHelper.userId && t.Name.Equals(model.Cell.TableId));
                var rule = demoHelper.dataRules.Find(w => w.Id == model.Id);
                var parentRule = demoHelper.rules.Find(r => r.EmailDataParsingRulesModels.Where(c => c.Id == rule.Id).FirstOrDefault().Equals(rule));

                if (rule != null)
                {
                    var parentId = rule.EmailParsingRulesModels.Id;

                    rule.Expression = HttpUtility.HtmlEncode(model.Expression);
                    rule.IsRegexpExpression = model.IsRegexpExpression.Equals(CultureHelper.GetStringForCurentCulture("RegularExpression"));
                    rule.DataExploration = (int)Enum.Parse(typeof(DataExplorationEnums), model.DataExploration);
                    rule.DataExplorationExpression = HttpUtility.HtmlEncode(model.DataExplorationExpression);
                    rule.IsChanging = model.IsChanging.Equals("C");
                    rule.ExpressionToChange = HttpUtility.HtmlEncode(model.ExpressionToChange);
                    rule.RegularExpressionToChange = HttpUtility.HtmlEncode(model.RegularExpressionToChange);
                    rule.ChangeTo = HttpUtility.HtmlEncode(model.ChangeTo);
                    rule.TableId_Id = table.Id;
                    rule.Worksheet = Convert.ToInt32(model.Cell.Worksheet);
                    rule.Column = (int)Enum.Parse(typeof(ColumnEnums), model.Cell.Column);
                    rule.ParsingMode = model.ParsingMode;
                    rule.ConsiderRegister = model.ConsiderRegister.Equals("C");
                    rule.Status = model.Status;
                    rule.IsUpdatingRule = parentRule.IsUpdatingRule;
                    // rule.IsUpdatindIndex = model.IsUpdatindIndex.Equals("C");
                    if (parentRule.IsUpdatingRule)
                    {
                        rule.ColumnForUpdate = (int)Enum.Parse(typeof(ColumnEnums), model.ColumnForUpdate);
                    }

                    return RedirectToAction("EditEmailDataParsingRule", new { ruleId = rule.Id });
                }
            }

            return View();
        }
示例#5
0
        public long AddNewRule(Oasis.Models.AddNewRuleModel model)
        {
            if (ModelState.IsValid)
            {
                    var id = demoHelper.rules.OrderBy(r => r.Id).Last().Id + 1;
                    var emailParsingRule = new Model.EmailParsingRulesModels
                    {
                        Id = id,
                        Name = HttpUtility.HtmlEncode(model.RuleName),
                        AuthorId_Id = demoHelper.userId,
                        Status = Model.Enums.RuleStatusEnums.Active.ToString(),
                        IsUpdatingRule = model.ForIsUpdating
                    };
                    demoHelper.rules.Add(emailParsingRule);

                    return emailParsingRule.Id;
            }
            return 0;
        }