Exemplo n.º 1
0
        public ActionResult EditEmailParsingRule(long ruleId)
        {
            var userId = UserHelper.GetUserByEmail(User.Identity.Name).Id;

            if (IsUsersEmailParsingRule(userId, ruleId))
            {
                var rule = emailParsingRulesRepository.Find(w => w.Id == ruleId);

                var user = UserHelper.GetUserByEmail(User.Identity.Name);

                var tables =
                    tablesRepository.FindAll(w => w.AspNetUsers.Id.Equals(user.Id)).Select(l => l.Name).ToList();

                List<SelectListItem> worksheetsList = new List<SelectListItem>();

                for (int i = 0; i < 10; i++)
                {
                   // worksheetsList.Add(new SelectListItem { Text = i.ToString(), Value = i.ToString() });
                     worksheetsList.Add(new SelectListItem { Text = Enum.GetName(typeof(WorksheetsNames), i) + " worksheet", Value = i.ToString() });

                   // Enum.GetName(typeof(DataExplorationEnums), updatingRule.DataExploration)
                }

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

                var saveEmailProperties = saveEmailPropertiesRepository.FindAll(w => w.EmailParsingRulesModelsId == ruleId && w.SaveEmailProp != null).ToList();

                if (rule != null)
                {
                    if (!rule.IsUpdatingRule)
                    {
                        var model = new EditRuleForEmailModel
                        {
                            Id = rule.Id,
                            Email = HttpUtility.HtmlDecode(rule.Email),
                            Subject = HttpUtility.HtmlDecode(rule.Subject),
                            PlainContains = HttpUtility.HtmlDecode(rule.PlainContains),
                            //IsUpdatingRule = rule.IsUpdatingRule.ToString(),
                            Name = rule.Name,
                            Tables = tables,
                            WorksheetsList = worksheetsList,
                            SaveEmail = saveEmail,
                            Status = rule.Status == null ? rule.Status = Model.Enums.RuleStatusEnums.Active.ToString() : rule.Status,
                            SaveEmailProperties = saveEmailProperties,
                            SaveEmailGroupItem = GetLayoutGroupForEmailParsingRule(rule.Id, tables, worksheetsList, saveEmail, rule.IsUpdatingRule, rule.CopyRuleFromPreviousOrder)
                        };
                        return PartialView(model);
                    }
                    else
                    {
                        var updatingRule = rule.EmailDataParsingRulesModels.Where(c => c.EmailParsingRulesModelsId_Id == rule.Id && c.IsUpdatindIndex).FirstOrDefault();
                        var table = tablesRepository.Find(t => t.Id == updatingRule.TableId_Id);

                        var updatingRuleModel = new EditRuleForDataModel();

                        if (updatingRule != null)
                        {
                            updatingRuleModel = new EditRuleForDataModel
                            {
                                Id = updatingRule.Id,
                                ParentId = rule.Id,
                                Expression = HttpUtility.HtmlDecode(updatingRule.Expression),
                                DataExplorationExpression = HttpUtility.HtmlDecode(updatingRule.DataExplorationExpression),
                                ExpressionToChange = HttpUtility.HtmlDecode(updatingRule.ExpressionToChange),
                                RegularExpressionToChange = HttpUtility.HtmlDecode(updatingRule.RegularExpressionToChange),
                                ChangeTo = HttpUtility.HtmlDecode(updatingRule.ChangeTo),
                                DataExploration = Enum.GetName(typeof(DataExplorationEnums), updatingRule.DataExploration),
                                IsUpdatindIndex = (updatingRule.IsUpdatindIndex).ToString(),
                                IsRegexpExpression = Convert.ToString(updatingRule.IsRegexpExpression),
                                IsChanging = Convert.ToString(updatingRule.IsChanging),
                                Status = updatingRule.Status == null ? rule.Status = Model.Enums.RuleStatusEnums.Active.ToString() : rule.Status,
                                ParsingMode = updatingRule.ParsingMode,
                                ConsiderRegister = (updatingRule.ConsiderRegister).ToString(),
                                IsUpdatingRule = false,
                                ColumnForUpdate = Convert.ToString(updatingRule.ColumnForUpdate)
                            };
                              if(table != null)
                                {
                                    updatingRuleModel.Cell = new CellModel { TableId = table.Name, Column = Convert.ToString(updatingRule.Column), Worksheet = Convert.ToString(updatingRule.Worksheet) };
                                }
                        }

                        var model = new EditUpdatingRuleForEmailModel
                        {
                            Id = rule.Id,
                            Email = HttpUtility.HtmlDecode(rule.Email),
                            Subject = HttpUtility.HtmlDecode(rule.Subject),
                            PlainContains = HttpUtility.HtmlDecode(rule.PlainContains),
                            Tables = tables,
                            WorksheetsList = worksheetsList,
                            Name = rule.Name,
                            SaveEmail = saveEmail,
                            Status = rule.Status == null ? rule.Status = Model.Enums.RuleStatusEnums.Active.ToString() : rule.Status,
                            SaveEmailProperties = saveEmailProperties,
                            SaveEmailGroupItem = GetLayoutGroupForEmailParsingRule(rule.Id, tables, worksheetsList, saveEmail, rule.IsUpdatingRule, rule.CopyRuleFromPreviousOrder),
                            UpdatingRule = updatingRuleModel
                        };
                        return PartialView("EditEmailParsingUpdatingRule", model);
                    }

                }
            }

            return RedirectToAction("ManageEmailParsingRules");
        }
Exemplo n.º 2
0
        public ActionResult EditEmailParsingRule(EditRuleForEmailModel model)
        {
            var userId = UserHelper.GetUserByEmail(User.Identity.Name).Id;

            if (ModelState.IsValid && IsUsersEmailParsingRule(userId, model.Id))
            {
                var rule = emailParsingRulesRepository.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 = saveEmailPropertiesRepository.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)
                            {
                                saveEmailPropertiesRepository.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)
                            {
                                saveEmailPropertiesRepository.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 = 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");
                    saveEmailPropertiesRepository.Commit();
                    emailParsingRulesRepository.Commit();

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

            return View();
        }
Exemplo n.º 3
0
        public long AddEmptySaveEmailProperty(EditRuleForEmailModel model)
        {
            var userId = UserHelper.GetUserByEmail(User.Identity.Name).Id;

            if (ModelState.IsValid && IsUsersEmailParsingRule(userId, model.Id))
            {
                var tables = tablesRepository.FindAll(w => w.AspNetUsers.Id.Equals(userId)).Select(l => l.Name).ToList();

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

                long spreadsheetId = ParseHelper.GetSpreadsheetIdByName(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 = 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;

                    var saveEmailProperties = model.SaveEmailProperties.Where(w => w.SaveEmailProp != null).ToList();

                    if (saveEmailProperties.Count == 0)
                    {
                        saveEmailPropertiesRepository.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)
                    {
                        saveEmailPropertiesRepository.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
                        });
                        saveEmailPropertiesRepository.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 = saveEmailPropertiesRepository.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;
                        }
                        saveEmailPropertiesRepository.Add(new Model.SaveEmailProperty()
                        {
                            TableId = tables[0],
                            Worksheet = "0",
                            Column = "A",
                            SaveEmailProp = saveEmail[0].Value,
                            EmailParsingRulesModelsId = rule.Id
                        });
                    }

                    saveEmailPropertiesRepository.Commit();
                    emailParsingRulesRepository.Commit();
                    return rule.Id;
                    // return RedirectToAction("AddNewDataRuleForEmails", new { ruleId = rule.Id });
                }
                return 0;
            }
            return 0;
        }