public bool SaveFileToDb(string filePath, long tableId)
{
byte[] file;
using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
using (var reader = new BinaryReader(stream))
{
file = reader.ReadBytes((int)stream.Length);
}
}
Repository<Model.TableModels> tablesRepository = new Repository<Model.TableModels>(new OasisProjectDbDataContext());
var table = tablesRepository.Find(w => w.Id == tableId);
if (table != null)
{
table.Content = file;
tablesRepository.Commit();
}
return false;
}
public ActionResult EditSpreadsheet(TableModels model)
{
try
{
var userId = UserHelper.GetUserByEmail(User.Identity.Name).Id;
if (ModelState.IsValid && IsUserAdmin(userId, model.Id))
{
var dateTime = DateTime.Now;
Repository<Model.TableModels> spreadsheetRepository = new Repository<Model.TableModels>();
var spreadsheet = spreadsheetRepository.Find(w => w.Id == model.Id);
if (spreadsheet != null)
{
spreadsheet.Name = model.Name;
}
spreadsheetRepository.Commit();
long brandNewTable =
spreadsheetRepository.Find(w => w.AuthorId_Id == userId && w.CreationDate == dateTime).Id;
return RedirectToAction("Spreadsheet", new { id = brandNewTable });
}
}
catch (Exception)
{
}
return RedirectToAction("ManageSpreadsheets");
}
public async Task<ActionResult> RegisterByInvite(RegisterByInviteViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// если создание прошло успешно, то добавляем роль пользователя
await UserManager.AddToRoleAsync(user.Id, UserRoles.Redactors.ToString());
await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
// Дополнительные сведения о том, как включить подтверждение учетной записи и сброс пароля, см. по адресу: http://go.microsoft.com/fwlink/?LinkID=320771
// Отправка сообщения электронной почты с этой ссылкой
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Подтверждение учетной записи", "Подтвердите вашу учетную запись, щелкнув <a href=\"" + callbackUrl + "\">здесь</a>");
Repository<AspNetUsers> userRepository = new Repository<AspNetUsers>();
var newUser = userRepository.Find(w => w.Email.Equals(model.Email));
if (newUser != null && newUser.CloudmailinEmail == null)
{
newUser.CloudmailinEmail = string.Format(Constants.PathConstants.Email,
newUser.Email.Replace("@", "at"));
if (newUser.Units == 0)
{
newUser.Units = 1;
}
userRepository.Commit();
if (model.adminEmail != null)
{
var admin = userRepository.Find(a => a.Email == SendMailHelper.Decrypt(model.adminEmail));
var redactor = new Model.TableRedactorModels()
{
Administrator_Id = admin.Id,
TableId = -1,
UserId_Id = newUser.Id
};
redactorsRepository.Commit();
}
}
return RedirectToAction("Index", "Home");
}
AddErrors(result);
}
// Появление этого сообщения означает наличие ошибки; повторное отображение формы
return View(model);
}
private static void ParseEmailData(long emailId, long ruleId)
{
// AddLog("ParseEmailData");
IRepository<EmailModels> emailRepository = new Repository<EmailModels>();
var email = emailRepository.Find(w => w.Id == emailId);
if (email != null)
{
int row = -1;
List<int> rows = new List<int>();
IRepository<EmailParsingRulesModels> emailParsingRulesRepository = new Repository<EmailParsingRulesModels>();
var emailParsingRule = emailParsingRulesRepository.Find(w => w.Id == ruleId);
if (emailParsingRule != null)
{
// AddLog("emailParsingRule != null");
List<Models.TablesList> tablesList = new List<Models.TablesList>();
IRepository<Model.SaveEmailProperty> saveEmailPropertiesRepository = new Repository<Model.SaveEmailProperty>();
var allDefaultValues = saveEmailPropertiesRepository.FindAll(i => i.EmailParsingRulesModelsId == emailParsingRule.Id).ToList();
IRepository<Model.TableModels> tablesRepository = new Repository<TableModels>();
IRepository<EmailDataParsingRulesModels> emailDataParsingRulesRepository =
new Repository<EmailDataParsingRulesModels>();
var emailDataParsingRules =
emailDataParsingRulesRepository.FindAll(
w => w.EmailParsingRulesModelsId_Id == emailParsingRule.Id &&
w.Status.Equals(Model.Enums.RuleStatusEnums.Active.ToString())).OrderBy(r => r.Name).ToList();
if (emailDataParsingRules != null && emailDataParsingRules.Count != 0)
{
// AddLog("emailDataParsingRules.Count != 0");
foreach (var dataParsingRule in emailDataParsingRules)
{
if (tablesList.Find(w => w.TableId == dataParsingRule.TableId_Id && w.IsChecked) == null && dataParsingRule.Status != Model.Enums.RuleStatusEnums.Paused.ToString())
{
var name = dataParsingRule.TableId_Id.ToString();
var path = SpreadsheetHelper.GetSpreadsheetPathById((long)dataParsingRule.TableId_Id);
try
{
SpreadsheetExtension.LoadDocument(name, path);
IWorkbook workbook = SpreadsheetExtension.GetCurrentDocument(name);
Worksheet worksheet =
workbook.Worksheets[
emailParsingRule.EmailDataParsingRulesModels.FirstOrDefault().Worksheet];
if (emailParsingRule.IsUpdatingRule)
{
var changing =
emailParsingRule.EmailDataParsingRulesModels.FirstOrDefault(
w =>
w.IsUpdatindIndex &&
w.EmailParsingRulesModelsId_Id == emailParsingRule.Id);
var changingIndex = BeforeParseValueFromEmail(email, changing);
if (path != null)
{
foreach (var c in worksheet.Columns[dataParsingRule.Column].ExistingCells)
{
var value = c.Value.ToString();
if (value.Equals(changingIndex))
{
row = c.RowIndex;
rows.Add(row);
}
}
byte[] size = workbook.SaveDocument(DocumentFormat.Xlsx);
tablesRepository.Find(t => t.Id == dataParsingRule.TableId_Id).Size = size.Length;
tablesRepository.Commit();
workbook.SaveDocument(path);
SpreadsheetExtension.CloseDocument(name);
}
}
else
{
worksheet.Rows.Insert(1);
row = 1;
}
if (row != -1)
{
var author_Id = emailParsingRule.AuthorId_Id;
foreach (var defaultValue in allDefaultValues)
{
if (emailParsingRule.Status != Model.Enums.RuleStatusEnums.Paused.ToString())
{
InsertEmailLink(emailId, defaultValue, row, author_Id, emailParsingRule.CopyRuleFromPreviousOrder);
}
}
foreach (
var dataParsing in
emailParsingRule.EmailDataParsingRulesModels.Where(
w => w.TableId_Id == dataParsingRule.TableId_Id))
{
if (dataParsing.Status != Model.Enums.RuleStatusEnums.Paused.ToString())
{
if (emailParsingRule.IsUpdatingRule)
{
foreach (var rowForUpdate in rows)
{
ParseCellValue(email, dataParsing, rowForUpdate, emailParsingRule.CopyRuleFromPreviousOrder);
}
rows.Clear();
}
else
{
ParseCellValue(email, dataParsing, row, emailParsingRule.CopyRuleFromPreviousOrder);
}
}
}
tablesList.Add(new TablesList
{
IsChecked = true,
TableId = (long)dataParsingRule.TableId_Id
});
}
}
catch
{
AddLog("Table not found");
}
}
}
}
else if (allDefaultValues != null)
{
var tablesInallDefaultValues = allDefaultValues.GroupBy(a => a.TableId).Select(g => g.First());
foreach (var defaultValue in tablesInallDefaultValues)
{
try
{
var name = tablesRepository.Find(w => w.Name == defaultValue.TableId && w.AuthorId_Id == emailParsingRule.AuthorId_Id).Name;
var path = SpreadsheetHelper.GetSpreadsheetPathById(tablesRepository.Find(w => w.Name == defaultValue.TableId && w.AuthorId_Id == emailParsingRule.AuthorId_Id).Id);
SpreadsheetExtension.LoadDocument(name, path);
IWorkbook workbook = SpreadsheetExtension.GetCurrentDocument(name);
Worksheet worksheet =
workbook.Worksheets[
Convert.ToInt32(defaultValue.Worksheet)];
worksheet.Rows.Insert(1);
row = 1;
byte[] size = workbook.SaveDocument(DocumentFormat.Xlsx);
tablesRepository.Find(w => w.Name == defaultValue.TableId && w.AuthorId_Id == emailParsingRule.AuthorId_Id).Size = size.Length;
tablesRepository.Commit();
workbook.SaveDocument(path);
SpreadsheetExtension.CloseDocument(name);
}
catch (Exception ex)
{
AddLog(ex.Message);
}
}
foreach (var defaultValue in allDefaultValues)
{
InsertEmailLink(emailId, defaultValue, row, emailParsingRule.AuthorId_Id, emailParsingRule.CopyRuleFromPreviousOrder);
}
}
}
}
}
private static void ParseCellValue(EmailModels email, EmailDataParsingRulesModels dataParsingRule, int row, bool CopyRuleFromPreviousOrder)
{
// AddLog("ParseCellValue");
var path = SpreadsheetHelper.GetSpreadsheetPathById((long)dataParsingRule.TableId_Id);
if (path != null)
{
var name = dataParsingRule.TableId_Id.ToString();
SpreadsheetExtension.LoadDocument(name, path);
IWorkbook workbook = SpreadsheetExtension.GetCurrentDocument(name);
Worksheet worksheet = workbook.Worksheets[dataParsingRule.Worksheet];
var value = BeforeParseValueFromEmail(email, dataParsingRule);
if (value != null)
{
if (dataParsingRule.IsUpdatingRule)
{
if (CopyRuleFromPreviousOrder)
{
worksheet.Cells[row, dataParsingRule.ColumnForUpdate].CopyFrom(worksheet.Cells[row + 1, dataParsingRule.ColumnForUpdate], PasteSpecial.Formats);
}
worksheet.Cells[row, dataParsingRule.ColumnForUpdate].Value = value.Replace("\n", " ");
}
else
{
if (CopyRuleFromPreviousOrder)
{
worksheet.Cells[row, dataParsingRule.Column].CopyFrom(worksheet.Cells[row + 1, dataParsingRule.Column], PasteSpecial.Formats);
}
worksheet.Cells[row, dataParsingRule.Column].Value = value.Replace("\n", " ");
}
}
workbook.SaveDocument(path);
SpreadsheetExtension.CloseDocument(name);
Repository<ParsedCells> parsedCellsRepository = new Repository<ParsedCells>();
var cell = new ParsedCells
{
Column = dataParsingRule.Column,
Content = value,
EmailId_Id = email.Id,
TableId_Id = dataParsingRule.TableId_Id,
Worksheet = dataParsingRule.Worksheet,
WorksheetName = worksheet.Name
};
parsedCellsRepository.Add(cell);
parsedCellsRepository.Commit();
}
}
private static void InsertEmailLink(long emailId, Model.SaveEmailProperty parsingRule, int row, string author_Id, bool CopyRuleFromPreviousOrder)
{
try
{
IRepository < Model.TableModels > tablesRepository = new Repository<TableModels>();
var tableId = tablesRepository.Find(w => w.Name==parsingRule.TableId && w.AuthorId_Id == author_Id).Id;
// AddLog(tableId.ToString());
var worksheetId = Convert.ToInt32(parsingRule.Worksheet);
var column = (int)Enum.Parse(typeof(ColumnEnums), parsingRule.Column);
var path = SpreadsheetHelper.GetSpreadsheetPathById(tableId);
if (path != null)
{
IRepository<TableModels> spreadsheetRepository = new Repository<TableModels>();
var name = spreadsheetRepository.Find(w => w.Id == tableId).Name;
SpreadsheetExtension.LoadDocument(name, path);
IWorkbook workbook = SpreadsheetExtension.GetCurrentDocument(name);
if (workbook.Worksheets.Count < worksheetId + 1)
{
int startWorksheets = workbook.Worksheets.Count;
for (int i = 0; i < worksheetId - startWorksheets + 1; i++)
{
workbook.Worksheets.Add();
}
}
Worksheet worksheet = workbook.Worksheets[worksheetId];
var cell = worksheet.Cells[row, column];
// AddLog("InsertEmailLink - " + "worksheet.Cells[" + row + ", " + column+"];");
if (parsingRule.SaveEmailProp != null)
{
worksheet.Hyperlinks.Add(cell, "javascript:OpenPopup(" + emailId + ")", false, "O");
cell.CopyFrom(worksheet.Cells[row + 1, column], PasteSpecial.Formats);
}
else if (parsingRule.DefaultValue != null)
{
if (CopyRuleFromPreviousOrder)
{
worksheet.Cells[row, column].CopyFrom(worksheet.Cells[row + 1, column], PasteSpecial.Formats);
}
worksheet.Cells[row, column].Value = parsingRule.DefaultValue;
}
byte[] size = workbook.SaveDocument(DocumentFormat.Xlsx);
tablesRepository.Find(w => w.Id == tableId).Size = size.Length;
tablesRepository.Commit();
workbook.SaveDocument(path);
SpreadsheetExtension.CloseDocument(name);
}
}
catch
{
}
}
