public void Dispose() => MessageService?.DismissMessage(Id);
private bool CreateCompositeKey()
{
m_pKey = new CompositeKey();
if (m_cbPassword.Checked) // Use a password
{
if (!m_icgPassword.ValidateData(true))
{
return(false);
}
uint uPwLen = m_icgPassword.PasswordLength;
if (uPwLen == 0)
{
if (!MessageService.AskYesNo(KPRes.EmptyMasterPw +
MessageService.NewParagraph + KPRes.EmptyMasterPwHint +
MessageService.NewParagraph + KPRes.EmptyMasterPwQuestion,
null, false))
{
return(false);
}
}
uint uMinLen = Program.Config.Security.MasterPassword.MinimumLength;
if (uPwLen < uMinLen)
{
string strML = KPRes.MasterPasswordMinLengthFailed;
strML = strML.Replace(@"{PARAM}", uMinLen.ToString());
MessageService.ShowWarning(strML);
return(false);
}
byte[] pb = m_icgPassword.GetPasswordUtf8();
uint uMinQual = Program.Config.Security.MasterPassword.MinimumQuality;
if (QualityEstimation.EstimatePasswordBits(pb) < uMinQual)
{
string strMQ = KPRes.MasterPasswordMinQualityFailed;
strMQ = strMQ.Replace(@"{PARAM}", uMinQual.ToString());
MessageService.ShowWarning(strMQ);
Array.Clear(pb, 0, pb.Length);
return(false);
}
string strValRes = Program.KeyValidatorPool.Validate(pb,
KeyValidationType.MasterPassword);
if (strValRes != null)
{
MessageService.ShowWarning(strValRes);
Array.Clear(pb, 0, pb.Length);
return(false);
}
m_pKey.AddUserKey(new KcpPassword(pb));
Array.Clear(pb, 0, pb.Length);
}
string strKeyFile = m_cmbKeyFile.Text;
bool bIsKeyProv = Program.KeyProviderPool.IsKeyProvider(strKeyFile);
if (m_cbKeyFile.Checked && (!strKeyFile.Equals(KPRes.NoKeyFileSpecifiedMeta)) &&
!bIsKeyProv)
{
try { m_pKey.AddUserKey(new KcpKeyFile(strKeyFile, true)); }
catch (InvalidDataException exID) // Selected database file
{
MessageService.ShowWarning(strKeyFile, exID);
return(false);
}
catch (Exception exKF)
{
MessageService.ShowWarning(strKeyFile, KPRes.KeyFileError, exKF);
return(false);
}
}
else if (m_cbKeyFile.Checked && (!strKeyFile.Equals(KPRes.NoKeyFileSpecifiedMeta)) &&
bIsKeyProv)
{
KeyProviderQueryContext ctxKP = new KeyProviderQueryContext(
m_ioInfo, true, false);
bool bPerformHash;
byte[] pbCustomKey = Program.KeyProviderPool.GetKey(strKeyFile, ctxKP,
out bPerformHash);
if ((pbCustomKey != null) && (pbCustomKey.Length > 0))
{
try { m_pKey.AddUserKey(new KcpCustomKey(strKeyFile, pbCustomKey, bPerformHash)); }
catch (Exception exCKP)
{
MessageService.ShowWarning(exCKP);
return(false);
}
Array.Clear(pbCustomKey, 0, pbCustomKey.Length);
}
else
{
return(false); // Provider has shown error message
}
}
if (m_cbUserAccount.Checked)
{
try { m_pKey.AddUserKey(new KcpUserAccount()); }
catch (Exception exUA)
{
MessageService.ShowWarning(exUA);
return(false);
}
}
return(true);
}
public HomeController(MessageService messageService)
{
_messageService = messageService;
}
async System.Threading.Tasks.Task DropNode(HashSet <SolutionItem> projectsToSave, object dataObject, HashSet <ProjectFile> groupedFiles, DragOperation operation)
{
FilePath targetDirectory = GetFolderPath(CurrentNode.DataItem);
FilePath source;
string what;
Project targetProject = (Project)CurrentNode.GetParentDataItem(typeof(Project), true);
Project sourceProject;
IEnumerable <ProjectFile> groupedChildren = null;
if (dataObject is ProjectFolder)
{
source = ((ProjectFolder)dataObject).Path;
sourceProject = ((ProjectFolder)dataObject).Project;
what = Path.GetFileName(source);
}
else if (dataObject is ProjectFile)
{
ProjectFile file = (ProjectFile)dataObject;
// if this ProjectFile is one of the grouped files being pulled in by a parent being copied/moved, ignore it
if (groupedFiles.Contains(file))
{
return;
}
if (file.DependsOnFile != null && operation == DragOperation.Move)
{
// unlink this file from its parent (since its parent is not being moved)
file.DependsOn = null;
// if moving a linked file into its containing folder, simply unlink it from its parent
if (file.FilePath.ParentDirectory == targetDirectory)
{
projectsToSave.Add(targetProject);
return;
}
}
sourceProject = file.Project;
if (sourceProject != null && file.IsLink)
{
source = sourceProject.BaseDirectory.Combine(file.ProjectVirtualPath);
}
else
{
source = file.FilePath;
}
groupedChildren = file.DependentChildren;
what = null;
}
else if (dataObject is Gtk.SelectionData)
{
SelectionData data = (SelectionData)dataObject;
if (data.Type != "text/uri-list")
{
return;
}
string sources = System.Text.Encoding.UTF8.GetString(data.Data);
Console.WriteLine("text/uri-list:\n{0}", sources);
string[] files = sources.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
for (int n = 0; n < files.Length; n++)
{
Uri uri = new Uri(files[n]);
if (uri.Scheme != "file")
{
return;
}
if (Directory.Exists(uri.LocalPath))
{
return;
}
files[n] = uri.LocalPath;
}
IdeApp.ProjectOperations.AddFilesToProject(targetProject, files, targetDirectory);
projectsToSave.Add(targetProject);
return;
}
else if (dataObject is SolutionFolderFileNode)
{
var sff = (SolutionFolderFileNode)dataObject;
sff.Parent.Files.Remove(sff.Path);
await IdeApp.ProjectOperations.SaveAsync(sff.Parent.ParentSolution);
source = ((SolutionFolderFileNode)dataObject).Path;
sourceProject = null;
what = null;
}
else
{
return;
}
var targetPath = targetDirectory.Combine(source.FileName);
// If copying to the same directory, make a copy with a different name
if (targetPath == source)
{
targetPath = ProjectOperations.GetTargetCopyName(targetPath, dataObject is ProjectFolder);
}
var targetChildPaths = groupedChildren != null?groupedChildren.Select(child => {
var targetChildPath = targetDirectory.Combine(child.FilePath.FileName);
if (targetChildPath == child.FilePath)
{
targetChildPath = ProjectOperations.GetTargetCopyName(targetChildPath, false);
}
return(targetChildPath);
}).ToList() : null;
if (dataObject is ProjectFolder)
{
string q;
if (operation == DragOperation.Move)
{
if (targetPath.ParentDirectory == targetProject.BaseDirectory)
{
q = GettextCatalog.GetString("Do you really want to move the folder '{0}' to the root folder of project '{1}'?", what, targetProject.Name);
}
else
{
q = GettextCatalog.GetString("Do you really want to move the folder '{0}' to the folder '{1}'?", what, targetDirectory.FileName);
}
if (!MessageService.Confirm(q, AlertButton.Move))
{
return;
}
}
else
{
if (targetPath.ParentDirectory == targetProject.BaseDirectory)
{
q = GettextCatalog.GetString("Do you really want to copy the folder '{0}' to the root folder of project '{1}'?", what, targetProject.Name);
}
else
{
q = GettextCatalog.GetString("Do you really want to copy the folder '{0}' to the folder '{1}'?", what, targetDirectory.FileName);
}
if (!MessageService.Confirm(q, AlertButton.Copy))
{
return;
}
}
}
else if (dataObject is ProjectFile)
{
var items = Enumerable.Repeat(targetPath, 1);
if (targetChildPaths != null)
{
items = items.Concat(targetChildPaths);
}
foreach (var file in items)
{
if (File.Exists(file))
{
if (!MessageService.Confirm(GettextCatalog.GetString("The file '{0}' already exists. Do you want to overwrite it?", file.FileName), AlertButton.OverwriteFile))
{
return;
}
}
}
}
var filesToSave = new List <Document> ();
foreach (Document doc in IdeApp.Workbench.Documents)
{
if (doc.IsDirty && doc.IsFile)
{
if (doc.Name == source || doc.Name.StartsWith(source + Path.DirectorySeparatorChar))
{
filesToSave.Add(doc);
}
else if (groupedChildren != null)
{
foreach (ProjectFile f in groupedChildren)
{
if (doc.Name == f.Name)
{
filesToSave.Add(doc);
}
}
}
}
}
if (filesToSave.Count > 0)
{
StringBuilder sb = new StringBuilder();
foreach (Document doc in filesToSave)
{
if (sb.Length > 0)
{
sb.Append(",\n");
}
sb.Append(Path.GetFileName(doc.Name));
}
string question;
if (operation == DragOperation.Move)
{
if (filesToSave.Count == 1)
{
question = GettextCatalog.GetString("Do you want to save the file '{0}' before the move operation?", sb.ToString());
}
else
{
question = GettextCatalog.GetString("Do you want to save the following files before the move operation?\n\n{0}", sb.ToString());
}
}
else
{
if (filesToSave.Count == 1)
{
question = GettextCatalog.GetString("Do you want to save the file '{0}' before the copy operation?", sb.ToString());
}
else
{
question = GettextCatalog.GetString("Do you want to save the following files before the copy operation?\n\n{0}", sb.ToString());
}
}
AlertButton noSave = new AlertButton(GettextCatalog.GetString("Don't Save"));
AlertButton res = MessageService.AskQuestion(question, AlertButton.Cancel, noSave, AlertButton.Save);
if (res == AlertButton.Cancel)
{
return;
}
if (res == AlertButton.Save)
{
try {
foreach (Document doc in filesToSave)
{
await doc.Save();
}
} catch (Exception ex) {
MessageService.ShowError(GettextCatalog.GetString("Save operation failed."), ex);
return;
}
}
}
if (operation == DragOperation.Move && sourceProject != null)
{
projectsToSave.Add(sourceProject);
}
if (targetProject != null)
{
projectsToSave.Add(targetProject);
}
bool move = operation == DragOperation.Move;
var opText = move ? GettextCatalog.GetString("Moving files...") : GettextCatalog.GetString("Copying files...");
using (var monitor = IdeApp.Workbench.ProgressMonitors.GetStatusProgressMonitor(opText, Stock.StatusSolutionOperation, true)) {
// If we drag and drop a node in the treeview corresponding to a directory, do not move
// the entire directory. We should only move the files which exist in the project. Otherwise
// we will need a lot of hacks all over the code to prevent us from incorrectly moving version
// control related files such as .svn directories
// Note: if we are transferring a ProjectFile, this will copy/move the ProjectFile's DependentChildren as well.
IdeApp.ProjectOperations.TransferFiles(monitor, sourceProject, source, targetProject, targetPath, move, sourceProject != null);
}
}
public void ShowError(Exception ex)
{
MessageService.ShowError(ex.ToString());
}
public void ShowError(string message)
{
MessageService.ShowError(message);
}
public ActionResult ClearMsgs()
{
MessageService.DeleteEntitySaved(m => m.Read);
return(ResultData(null, true, "站内消息清除成功！"));
}
public ActionResult GetUnreadMsgs()
{
IEnumerable <InternalMessage> msgs = MessageService.GetQueryNoTracking(m => !m.Read, m => m.Time, false);
return(ResultData(msgs));
}
public ActionResult DeleteMsg(int id)
{
bool b = MessageService.DeleteByIdSaved(id);
return(ResultData(null, b, b ? "站内消息删除成功！" : "站内消息删除失败！"));
}
public void ShowError(Exception ex, string message)
{
MessageService.ShowError(message + Environment.NewLine + ex.ToString());
}
private async Task <TestResult> RunCommand(Commands cmd, bool test, bool projRecurse = true)
{
VersionControlItemList items = GetItems(projRecurse);
foreach (VersionControlItem it in items)
{
if (it.Repository == null)
{
if (cmd != Commands.Publish)
{
return(TestResult.NoVersionControl);
}
}
else if (it.Repository.VersionControlSystem != null && !it.Repository.VersionControlSystem.IsInstalled)
{
return(TestResult.Disable);
}
}
bool res = false;
try {
switch (cmd)
{
case Commands.Update:
res = UpdateCommand.Update(items, test);
break;
case Commands.Diff:
res = await DiffCommand.Show(items, test);
break;
case Commands.Log:
res = await LogCommand.Show(items, test);
break;
case Commands.Status:
res = StatusView.Show(items, test, false);
break;
case Commands.Add:
res = AddCommand.Add(items, test);
break;
case Commands.Remove:
res = RemoveCommand.Remove(items, test);
break;
case Commands.Revert:
res = RevertCommand.Revert(items, test);
break;
case Commands.Lock:
res = LockCommand.Lock(items, test);
break;
case Commands.Unlock:
res = UnlockCommand.Unlock(items, test);
break;
case Commands.Publish:
VersionControlItem it = items [0];
if (items.Count == 1 && it.IsDirectory && it.WorkspaceObject != null)
{
res = PublishCommand.Publish(it.WorkspaceObject, it.Path, test);
}
break;
case Commands.Annotate:
res = await BlameCommand.Show(items, test);
break;
case Commands.CreatePatch:
res = CreatePatchCommand.CreatePatch(items, test);
break;
case Commands.Ignore:
res = IgnoreCommand.Ignore(items, test);
break;
case Commands.Unignore:
res = UnignoreCommand.Unignore(items, test);
break;
case Commands.ResolveConflicts:
res = await ResolveConflictsCommand.ResolveConflicts(items, test);
break;
}
}
catch (Exception ex) {
if (test)
{
LoggingService.LogError(ex.ToString());
}
else
{
MessageService.ShowError(GettextCatalog.GetString("Version control command failed."), ex);
}
return(TestResult.Disable);
}
return(res ? TestResult.Enable : TestResult.Disable);
}
public async void AddExistingFolder()
{
var project = (Project)CurrentNode.GetParentDataItem(typeof(Project), true);
var selectedFolder = ((FilePath)GetFolderPath(CurrentNode.DataItem)).CanonicalPath;
var ofdlg = new SelectFolderDialog(GettextCatalog.GetString("Add Existing Folder"))
{
CurrentFolder = !PreviousFolderPath.IsNullOrEmpty ? PreviousFolderPath : selectedFolder
};
if (!ofdlg.Run())
{
return;
}
// We store the parent directory of the folder the user chooses as they will not need to add the same
// directory twice. We can save them navigating up one directory by doing it for them
PreviousFolderPath = ofdlg.SelectedFile.CanonicalPath;
if (!PreviousFolderPath.ParentDirectory.IsNullOrEmpty)
{
PreviousFolderPath = PreviousFolderPath.ParentDirectory;
}
var srcRoot = ofdlg.SelectedFile.CanonicalPath;
var targetRoot = selectedFolder.Combine(srcRoot.FileName);
bool changedProject = false;
if (File.Exists(targetRoot))
{
MessageService.ShowWarning(GettextCatalog.GetString(
"There is already a file with the name '{0}' in the target directory", srcRoot.FileName));
return;
}
var existingPf = project.Files.GetFileWithVirtualPath(targetRoot.ToRelative(project.BaseDirectory));
if (existingPf != null)
{
if (existingPf.Subtype != Subtype.Directory)
{
MessageService.ShowWarning(GettextCatalog.GetString(
"There is already a link with the name '{0}' in the target directory", srcRoot.FileName));
return;
}
}
var foundFiles = Directory.GetFiles(srcRoot, "*", SearchOption.AllDirectories);
using (var impdlg = new IncludeNewFilesDialog(GettextCatalog.GetString("Select files to add from {0}", srcRoot.FileName), srcRoot.ParentDirectory)) {
impdlg.AddFiles(foundFiles);
if (MessageService.ShowCustomDialog(impdlg) == (int)ResponseType.Ok)
{
var srcFiles = impdlg.SelectedFiles;
var targetFiles = srcFiles.Select(f => targetRoot.Combine(f.ToRelative(srcRoot)));
if (IdeApp.ProjectOperations.AddFilesToProject(project, srcFiles.ToArray(), targetFiles.ToArray(), null).Any())
{
changedProject = true;
}
else if (!srcFiles.Any() && existingPf == null)
{
// Just add empty folder.
project.Files.Add(new ProjectFile(targetRoot)
{
Subtype = Subtype.Directory
});
changedProject = true;
}
}
if (changedProject)
{
await IdeApp.ProjectOperations.SaveAsync(project);
}
}
}
protected void SaveOrUpdateInvoice(Object sender, CommandEventArgs e)
{
try
{
var dao = Global.DaoFactory;
var invoice = GetInvoice();
var billingAddressID = Convert.ToInt32(Request["billingAddressID"]);
var deliveryAddressID = Convert.ToInt32(Request["deliveryAddressID"]);
var messageAction = MessageAction.InvoiceCreated;
if (invoice.ID > 0)
{
messageAction = MessageAction.InvoiceUpdated;
RemoveInvoiceFile(invoice.FileID);
}
invoice.ID = dao.GetInvoiceDao().SaveOrUpdateInvoice(invoice);
MessageService.Send(HttpContext.Current.Request, messageAction, invoice.Number);
var invoiceLines = GetInvoiceLines();
foreach (var line in invoiceLines)
{
line.InvoiceID = invoice.ID;
line.ID = dao.GetInvoiceLineDao().SaveOrUpdateInvoiceLine(line);
}
RemoveUnusedLines(invoice.ID, invoiceLines);
dao.GetInvoiceDao().UpdateInvoiceJsonData(invoice, billingAddressID, deliveryAddressID);
if (Global.CanDownloadInvoices)
{
new InvoiceFileUpdateHelper().UpdateInvoiceFileIDInThread(invoice.ID);
}
string redirectUrl;
if (ActionType == InvoiceActionType.Create && UrlParameters.ContactID != 0)
{
redirectUrl = string.Format(e.CommandArgument.ToString() == "1" ? "invoices.aspx?action=create&contactID={0}" : "default.aspx?id={0}#invoices", UrlParameters.ContactID);
}
else
{
redirectUrl = e.CommandArgument.ToString() == "1" ? "invoices.aspx?action=create" : string.Format("invoices.aspx?id={0}", invoice.ID);
}
Response.Redirect(redirectUrl, false);
Context.ApplicationInstance.CompleteRequest();
}
catch (Exception ex)
{
log4net.LogManager.GetLogger("ASC.CRM").Error(ex);
var cookie = HttpContext.Current.Request.Cookies.Get(ErrorCookieKey);
if (cookie == null)
{
cookie = new HttpCookie(ErrorCookieKey)
{
Value = ex.Message
};
HttpContext.Current.Response.Cookies.Add(cookie);
}
}
}
async Task <bool> SaveAsTask(string filename)
{
if (Window.ViewContent.IsViewOnly || !Window.ViewContent.IsFile)
{
return(false);
}
Encoding encoding = null;
var tbuffer = GetContent <ITextSource> ();
if (tbuffer != null)
{
encoding = tbuffer.Encoding;
if (encoding == null)
{
encoding = Encoding.UTF8;
}
}
if (filename == null)
{
var dlg = new OpenFileDialog(GettextCatalog.GetString("Save as..."), MonoDevelop.Components.FileChooserAction.Save)
{
TransientFor = IdeApp.Workbench.RootWindow,
Encoding = encoding,
ShowEncodingSelector = (tbuffer != null),
};
if (Window.ViewContent.IsUntitled)
{
dlg.InitialFileName = Window.ViewContent.UntitledName;
}
else
{
dlg.CurrentFolder = Path.GetDirectoryName((string)Window.ViewContent.ContentName);
dlg.InitialFileName = Path.GetFileName((string)Window.ViewContent.ContentName);
}
if (!dlg.Run())
{
return(false);
}
filename = dlg.SelectedFile;
encoding = dlg.Encoding;
}
if (!FileService.IsValidPath(filename))
{
MessageService.ShowMessage(GettextCatalog.GetString("File name {0} is invalid", filename));
return(false);
}
// detect preexisting file
if (File.Exists(filename))
{
if (!MessageService.Confirm(GettextCatalog.GetString("File {0} already exists. Overwrite?", filename), AlertButton.OverwriteFile))
{
return(false);
}
}
// save backup first
if (IdeApp.Preferences.CreateFileBackupCopies)
{
if (tbuffer != null && encoding != null)
{
TextFileUtility.WriteText(filename + "~", tbuffer.Text, encoding);
}
else
{
await Window.ViewContent.Save(new FileSaveInformation (filename + "~", encoding));
}
}
TypeSystemService.RemoveSkippedfile(FileName);
// do actual save
Window.ViewContent.ContentName = filename;
Window.ViewContent.Project = Workbench.GetProjectContainingFile(filename);
await Window.ViewContent.Save(new FileSaveInformation (filename, encoding));
DesktopService.RecentFiles.AddFile(filename, (Project)null);
OnSaved(EventArgs.Empty);
await UpdateParseDocument();
return(true);
}
async Task SaveTask()
{
// suspend type service "check all file loop" since we have already a parsed document.
// Or at least one that updates "soon".
try {
// Freeze the file change events. There can be several such events, and sending them all together
// is more efficient
FileService.FreezeEvents();
if (Window.ViewContent.IsViewOnly || !Window.ViewContent.IsDirty)
{
return;
}
if (!Window.ViewContent.IsFile)
{
await Window.ViewContent.Save();
return;
}
if (IsUntitled)
{
await SaveAs();
}
else
{
try {
FileService.RequestFileEdit((FilePath)Window.ViewContent.ContentName, true);
} catch (Exception ex) {
MessageService.ShowError(GettextCatalog.GetString("The file could not be saved."), ex.Message, ex);
}
FileAttributes attr = FileAttributes.ReadOnly | FileAttributes.Directory | FileAttributes.Offline | FileAttributes.System;
if (!File.Exists((string)Window.ViewContent.ContentName) || (File.GetAttributes((string)window.ViewContent.ContentName) & attr) != 0)
{
await SaveAs();
}
else
{
string fileName = Window.ViewContent.ContentName;
// save backup first
if (IdeApp.Preferences.CreateFileBackupCopies)
{
await Window.ViewContent.Save(fileName + "~");
FileService.NotifyFileChanged(fileName + "~");
}
await Window.ViewContent.Save(fileName);
FileService.NotifyFileChanged(fileName);
OnSaved(EventArgs.Empty);
}
}
} finally {
// Send all file change notifications
FileService.ThawEvents();
// Set the file time of the current document after the file time of the written file, to prevent double file updates.
// Note that the parsed document may be overwritten by a background thread to a more recent one.
var doc = parsedDocument;
if (doc != null)
{
string fileName = Window.ViewContent.ContentName;
try {
// filename could be null if the user cancelled SaveAs and this is a new & unsaved file
if (fileName != null)
{
doc.LastWriteTimeUtc = File.GetLastWriteTimeUtc(fileName);
}
} catch (Exception e) {
doc.LastWriteTimeUtc = DateTime.UtcNow;
LoggingService.LogWarning("Exception while getting the write time from " + fileName, e);
}
}
}
}
public ActionResult Put(LeaveMessageInputDto dto)
{
if (Regex.Match(dto.Content, CommonHelper.BanRegex).Length > 0)
{
return(ResultData(null, false, "您提交的内容包含敏感词，被禁止发表，请检查您的内容后尝试重新提交！"));
}
dto.Content = dto.Content.Trim().Replace("<p><br></p>", string.Empty);
if (dto.Content.RemoveHtmlTag().Trim().Equals(HttpContext.Session.Get <string>("msg")))
{
return(ResultData(null, false, "您刚才已经发表过一次留言了！"));
}
var msg = dto.Mapper <LeaveMessage>();
if (Regex.Match(dto.Content, CommonHelper.ModRegex).Length <= 0)
{
msg.Status = Status.Pended;
}
msg.PostDate = DateTime.Now;
var user = HttpContext.Session.Get <UserInfoOutputDto>(SessionKey.UserInfo);
if (user != null)
{
msg.NickName = user.NickName;
msg.QQorWechat = user.QQorWechat;
msg.Email = user.Email;
if (user.IsAdmin)
{
msg.Status = Status.Pended;
msg.IsMaster = true;
}
}
msg.Content = dto.Content.HtmlSantinizerStandard().ClearImgAttributes();
msg.Browser = dto.Browser ?? Request.Headers[HeaderNames.UserAgent];
msg.IP = HttpContext.Connection.RemoteIpAddress.MapToIPv4().ToString();
msg.Location = msg.IP.GetIPLocation().Split("|").Where(s => !int.TryParse(s, out _)).ToHashSet().Join("|");
msg = LeaveMessageService.AddEntitySaved(msg);
if (msg == null)
{
return(ResultData(null, false, "留言发表失败！"));
}
HttpContext.Session.Set("msg", msg.Content.RemoveHtmlTag().Trim());
var email = CommonHelper.SystemSettings["ReceiveEmail"];
var content = System.IO.File.ReadAllText(HostEnvironment.WebRootPath + "/template/notify.html").Replace("{{title}}", "网站留言板").Replace("{{time}}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")).Replace("{{nickname}}", msg.NickName).Replace("{{content}}", msg.Content);
if (msg.Status == Status.Pended)
{
if (!msg.IsMaster)
{
MessageService.AddEntitySaved(new InternalMessage()
{
Title = $"来自【{msg.NickName}】的新留言",
Content = msg.Content,
Link = Url.Action("Index", "Msg", new { cid = msg.Id }, Request.Scheme)
});
}
#if !DEBUG
if (msg.ParentId == 0)
{
//新评论，只通知博主
BackgroundJob.Enqueue(() => CommonHelper.SendMail(CommonHelper.SystemSettings["Domain"] + "|博客新留言：", content.Replace("{{link}}", Url.Action("Index", "Msg", new { cid = msg.Id }, Request.Scheme)), email));
}
else
{
//通知博主和上层所有关联的评论访客
var pid = LeaveMessageService.GetParentMessageIdByChildId(msg.Id);
var emails = LeaveMessageService.GetSelfAndAllChildrenMessagesByParentId(pid).Select(c => c.Email).Append(email).Except(new[] { msg.Email }).ToHashSet();
string link = Url.Action("Index", "Msg", new { cid = msg.Id }, Request.Scheme);
foreach (var s in emails)
{
BackgroundJob.Enqueue(() => CommonHelper.SendMail($"{CommonHelper.SystemSettings["Domain"]}{CommonHelper.SystemSettings["Title"]} 留言回复：", content.Replace("{{link}}", link), s));
}
}
#endif
return(ResultData(null, true, "留言发表成功，服务器正在后台处理中，这会有一定的延迟，稍后将会显示到列表中！"));
}
BackgroundJob.Enqueue(() => CommonHelper.SendMail(CommonHelper.SystemSettings["Domain"] + "|博客新留言(待审核)：", content.Replace("{{link}}", Url.Action("Index", "Msg", new
{
cid = msg.Id
}, Request.Scheme)) + "<p style='color:red;'>(待审核)</p>", email));
return(ResultData(null, true, "留言发表成功，待站长审核通过以后将显示到列表中！"));
}
public Result <Message> Send(Message message)
{
message.SenderEmail = HttpUtil.UserProfile.Email;
return(MessageService.Save(message));
}
public List <Message> GetMessages(string receiver)
{
return(MessageService.GetAllBySenderReceiver(HttpUtil.UserProfile.Email, receiver));
}
public void Unsubscribe()
{
MessageService.Unsubscribe(this);
}
//public async Task LoadAsync(ExpenseHeadDetailsArgs args)
//{
// ViewModelArgs = args ?? ExpenseHeadDetailsArgs.CreateDefault();
// if (ViewModelArgs.IsNew)
// {
// Item = new TalukModel();
// IsEditMode = true;
// }
// else
// {
// try
// {
// var item = await TalukService.GetTalukAsync(ViewModelArgs.ExpenseHeadId);
// Item = item ?? new ExpenseHeadModel { ExpenseHeadId = ViewModelArgs.ExpenseHeadId, IsEmpty = true };
// }
// catch (Exception ex)
// {
// LogException("ExpenseHead", "Load", ex);
// }
// }
//}
//public void Unload()
//{
// ViewModelArgs.ExpenseHeadId = Item?.ExpenseHeadId ?? 0;
//}
public void Subscribe()
{
MessageService.Subscribe <TalukDetailsViewModel, TalukModel>(this, OnDetailsMessage);
MessageService.Subscribe <TalukListViewModel>(this, OnListMessage);
}
public void AddService ( MessageService service ) {
service.Received += new MessageEventHandler(this.BlipReceived);
//service.Sent += new QueueEventHandler(this.MessageSent);
//service.Connected += new QueueEventHandler(this.ClientConnected);
service.Failure += new QueueFailureEventHandler(this.FailureRaised);
// not really used for now...
services.Add(service);
}
public static void Main(string[] args)
{
var video = new Video() { Title = "Video 1"};
var videoEncoder = new VideoEncoder(); //publisher
var mailService = new MailService(); //subscriber
var messageService = new MessageService();
videoEncoder.VideoEncoded += mailService.OnVideoEncoded;
videoEncoder.VideoEncoded += messageService.OnVideoEncoded;
videoEncoder.Encode(video);
}
public void MessageService__Calls_AdminSvc_WithSelectedClusters()
{
var mockAdminSvc = new Mock<IAdmin>();
var mockMessageCoordinator = new Mock<IMessageCoordinator>();
var recipientCriterion = new RecipientCriterion(1, new []{1,2}, false,false);
var sut = new MessageService(mockAdminSvc.Object, mockMessageCoordinator.Object);
sut.SendMessageToDisasterVolunteers(new Message("Body","Subject"), recipientCriterion );
mockAdminSvc.Verify(m=>m.GetVolunteersForDate(1,DateTime.Today,false,false, recipientCriterion.ClusterIds), Times.Once());
}
public ChatViewModel(Window currentWindow)
{
this.currentWindow = currentWindow;
CreateSendCommand();
CreateCloseCommand();
MessageViewService = new MessageViewService();
MessageService = new MessageService(MessageViewService);
LogService = new LogService(MessageViewService);
UserService = new UserService(MessageViewService);
DispatcherTimer t = new DispatcherTimer();
t.Interval = new TimeSpan(2000);
t.Tick += new EventHandler(t_Tick);
t.Start();
}
public void SaveMessageTest()
{
MessageService target = new MessageService(); // TODO: Initialize to an appropriate value
Message input = new Message();
input.MessageID = "MessageID1";
input.MessagePutTime = DateTime.Now;
input.MessageReadTime = DateTime.Now;
input.Guid = Guid.NewGuid();
input.Name = "Johnny";
input.SubscriptionID = "SubscriptionID1";
int expected = 1; // TODO: Initialize to an appropriate value
int actual;
actual = target.SaveMessage(input);
Assert.AreEqual(expected, actual);
}
public void WillNotSendEmailToOwnerThatOptsOut()
{
var from = new MailAddress("*****@*****.**", "flossy");
var package = new PackageRegistration { Id = "smangit" };
package.Owners = new[] {
new User {EmailAddress = "*****@*****.**", EmailAllowed = true },
new User {EmailAddress = "*****@*****.**", EmailAllowed = false }
};
var mailSender = new Mock<IMailSender>();
var setting = new GallerySetting { GalleryOwnerName = "Joe Schmoe", GalleryOwnerEmail = "*****@*****.**" };
var messageService = new MessageService(mailSender.Object, setting);
var message = messageService.SendContactOwnersMessage(from, package, "Test message", "http://someurl/");
Assert.Equal("*****@*****.**", message.To[0].Address);
Assert.Equal(1, message.To.Count);
}
public void WillNotAttemptToSendIfNoOwnersAllow()
{
var from = new MailAddress("*****@*****.**", "flossy");
var package = new PackageRegistration { Id = "smangit" };
package.Owners = new[] {
new User {EmailAddress = "*****@*****.**", EmailAllowed = false },
new User {EmailAddress = "*****@*****.**", EmailAllowed = false }
};
var mailSender = new Mock<IMailSender>();
mailSender.Setup(m => m.Send(It.IsAny<MailMessage>())).Throws(new InvalidOperationException());
var setting = new GallerySetting { GalleryOwnerName = "Joe Schmoe", GalleryOwnerEmail = "*****@*****.**" };
var messageService = new MessageService(mailSender.Object, setting);
var message = messageService.SendContactOwnersMessage(from, package, "Test message", "http://someurl/");
Assert.Equal(0, message.To.Count);
}
public static void MessageLoop(string clientName, string message, int messagesPerMinute, int totalMessages)
{
int sleepTime = 60/messagesPerMinute*1000;
for(int i = 0; i < totalMessages; i++)
{
MessageService ms = new MessageService();
foreach (var subscriber in MessageService._subscribers)
{
if(subscriber.Value == clientName)
{
subscriber.Key.OnMessageAdded(message, DateTime.Now);
}
}
//ms.OnMessageAdded(message, DateTime.Now);
//MessageService._subscribers.AddMessage(message, clientName);
Console.WriteLine("Sending Message");
Thread.Sleep(sleepTime);
}
}
static void Main(string[] args)
{
Video myVideo = new Video();
myVideo.Title = "Video 1";
VideoEncoder myVideoEncoder = new VideoEncoder(); // Publisher
MailService myMailService = new MailService(); // Subscriber
MessageService myMessageService = new MessageService(); // Another subscriber
myVideoEncoder.VideoEncoded += myMessageService.OnVideoEncoded;
myVideoEncoder.VideoEncoded += myMailService.OnVideoEncoded; /* Code explanation:
* the object "myVideoEncoder" has an event called "VideoEncoded",
* we then add the "OnVideoEncoded" method from "myMailService" as a subscriber,
* so that when "myVideoEncoder" raises the event "VideoEncoded", the
* function: "OnVideoEncoded" is called from the class: "myMailService".
*/
myVideoEncoder.Encode(myVideo);
}
public void MessageService__DoesNotFail_With_Empty_VolunteerList()
{
const string sender = "Sender Name";
var mockAdminSvc = new Mock<IAdmin>();
var volunteers = new List<Person>();
volunteers.Add(new Person { Id = 1, Email = "email-1", FirstName = "first", LastName = "last" });
volunteers.Add(new Person { Id = 2, Email = "email-2", FirstName = "first", LastName = "last" });
mockAdminSvc.Setup(x => x.GetVolunteersForDate(It.IsAny<int>(), DateTime.Today, false, false)).Returns(volunteers);
var mockMessageCoordinator = new Mock<IMessageCoordinator>();
var expectedMessage = new Message("body", "subject");
var expectedRecipients = new List<MessageRecipient>();
var sut = new MessageService(mockAdminSvc.Object, mockMessageCoordinator.Object);
sut.SendMessageToDisasterVolunteers(expectedMessage, new RecipientCriterion(42), sender);
mockMessageCoordinator.Verify(x => x.SendMessage(expectedMessage, It.Is<List<MessageRecipient>>(y => y.Count.Equals(2)), sender), Times.Once());
}
public void MessageService__Calls_MessageCoordinator_WithProperVolunteerList()
{
var mockAdminSvc = new Mock<IAdmin>();
var volunteers = new List<Person>();
volunteers.Add(new Person { Id = 1, Email = "email-1", FirstName = "first", LastName = "last" });
volunteers.Add(new Person { Id = 2, Email = "email-2", FirstName = "first", LastName = "last" });
mockAdminSvc.Setup(x => x.GetVolunteersForDate(It.IsAny<int>(), DateTime.Today)).Returns(volunteers);
var mockMessageCoordinator = new Mock<IMessageCoordinator>();
var expectedMessage = new Message("body", "subject");
var expectedRecipients = new List<MessageRecipient>();
expectedRecipients.Add(new MessageRecipient { EmailAddress = "email-1", Name = "first last" });
expectedRecipients.Add(new MessageRecipient { EmailAddress = "email-2", Name = "first last" });
var sut = new MessageService(mockAdminSvc.Object, mockMessageCoordinator.Object);
sut.SendMessageToDisasterVolunteers(new RecipientCriterion(42), expectedMessage);
mockMessageCoordinator.Verify(x => x.SendMessage(expectedMessage, It.Is<List<MessageRecipient>>(y => y.Count.Equals(2))), Times.Once());
}
public void MustGenereteDiffrentHashForDiffierentString()
{
var messageService = new MessageService();
var hashes = new List<long>();
for (int i = 0; i < 10000; i++)
{
hashes.Add(messageService.CreateMessageHash(new MessageDefinition
{
MessageId = Guid.NewGuid().ToString() + i
}));
}
int c = 0;
while (hashes.Count > 0)
{
c++;
var l = hashes[0];
hashes.RemoveAt(0);
Assert.IsFalse(hashes.Contains(l), string.Format("Count: {0} for {1}", c, l));
}
}
public void HashMustEqualForEqualString()
{
var messageService = new MessageService();
var hashes = new List<long>();
var value = Guid.NewGuid().ToString();
for (int i = 0; i < 100000; i++)
{
hashes.Add(messageService.CreateMessageHash(new MessageDefinition
{
MessageId = value
}));
}
var head = hashes[0];
for (int ci = 1; ci < hashes.Count; ci++)
{
Assert.AreEqual(head, hashes[ci]);
}
}
public void GetMessageTest()
{
MessageService target = new MessageService(); // TODO: Initialize to an appropriate value
Message input = new Message();
input.MessageID = "MessageID1";
input.MessagePutTime = DateTime.Now;
input.MessageReadTime = DateTime.Now;
input.Guid = Guid.NewGuid();
input.Name = "Johnny";
input.SubscriptionID = "SubscriptionID1";
var result = target.SaveMessage(input);
Message actual;
actual = target.GetMessage(result);
Assert.AreEqual(1, actual.ID);
target.DeleteMessage(input);
actual = target.GetMessage(input.ID);
Assert.AreEqual(null, actual);
}
public void WillSendEmailToAllOwners()
{
var from = new MailAddress("*****@*****.**", "flossy");
var package = new PackageRegistration { Id = "smangit" };
package.Owners = new[] {
new User {EmailAddress = "*****@*****.**", EmailAllowed = true },
new User {EmailAddress = "*****@*****.**", EmailAllowed = true }
};
var mailSender = new Mock<IMailSender>();
var setting = new GallerySetting { GalleryOwnerName = "NuGet Gallery", GalleryOwnerEmail = "*****@*****.**" };
var messageService = new MessageService(mailSender.Object, setting);
var message = messageService.SendContactOwnersMessage(from, package, "Test message", "http://someurl/");
mailSender.Verify(m => m.Send(It.IsAny<MailMessage>()));
Assert.Equal("*****@*****.**", message.To[0].Address);
Assert.Equal("*****@*****.**", message.To[1].Address);
Assert.Contains("[NuGet Gallery] Message for owners of the package 'smangit'", message.Subject);
Assert.Contains("Test message", message.Body);
Assert.Contains("User flossy <[email protected]> sends the following message to the owners of Package 'smangit'.", message.Body);
}
public void AddMeeting(Meeting meeting, string userParticipants, string otherParticipants)
{
var ms = new MessageService();
if (!String.IsNullOrEmpty(userParticipants))
{
var users =
userParticipants.Trim().Split(' ').Select(int.Parse).Select(
id => Database.Users.FirstOrDefault(u => u.Id == id));
users.ToList().ForEach((user) =>
{
meeting.Participants.Add(user);
ms.SendMeetingInvitation(user.Email, meeting);
});
}
if (!string.IsNullOrEmpty(otherParticipants))
{
var emails = otherParticipants.Trim().Split(' ').ToList();
foreach (var email in emails)
{
var trygetUser = Database.Users.FirstOrDefault(u => u.Email == email);
if (trygetUser == null)
{
trygetUser = new User
{
Email = email,
AccountType = UserAccountType.MeetingParticipant,
PasswordHash = MD5.EncryptMD5(email)
};
Database.Users.Add(trygetUser);
ms.SendMeetingInvitation(trygetUser.Email, meeting, false);
}
else
ms.SendMeetingInvitation(trygetUser.Email, meeting);
meeting.Participants.Add(trygetUser);
}
}
Database.Meetings.Add(meeting);
Database.SaveChanges();
}
public void RemoveService ( MessageService service ) {
services.Remove(service);
}
public override void Configure(Container container)
{
LogManager.LogFactory = new Log4NetFactory(true);
container.Register(_dbConnectionFactory);
var basicAuthProvider = new BasicAuthProvider();
container.Register(basicAuthProvider);
Plugins.Add(new AuthFeature( () => new AuthUserSession(), new IAuthProvider[] {basicAuthProvider, }, SystemConstants.LoginUrl ));
var userRepo = new OrmLiteAuthRepository(_dbConnectionFactory);
container.Register<IAuthRepository>(userRepo);
var cacheClient = new MemoryCacheClient();
container.Register(cacheClient);
var currencyTypeRepository = new CurrencyTypeRepository { DbConnectionFactory = _dbConnectionFactory };
var transactionTypeRepository = new TransactionTypeRepository { DbConnectionFactory = _dbConnectionFactory };
var transactionStatusTypeRepository = new TransactionStatusTypeRepository { DbConnectionFactory = _dbConnectionFactory };
var transactionNotificationStatusTypeRepository = new TransactionNotificationStatusTypeRepository { DbConnectionFactory = _dbConnectionFactory };
var transactionRepository = new TransactionRepository { DbConnectionFactory = _dbConnectionFactory };
var currencyTypeLogic = new CurrencyTypeLogic { Repository = currencyTypeRepository };
var transactionTypeLogic = new TransactionTypeLogic { Repository = transactionTypeRepository };
var transactionStatusTypeLogic = new TransactionStatusTypeLogic { Repository = transactionStatusTypeRepository };
var transactionNotificationStatusTypeLogic = new TransactionNotificationStatusTypeLogic { Repository = transactionNotificationStatusTypeRepository };
var transactionLogic = new TransactionLogic {Repository = transactionRepository};
container.Register<IRest<CurrencyType, GetCurrencyTypes>>(currencyTypeLogic);
container.Register<IRest<TransactionType, GetTransactionTypes>>(transactionTypeLogic);
container.Register<IRest<TransactionStatusType, GetTransactionStatusTypes>>(transactionStatusTypeLogic);
container.Register<IRest<TransactionNotificationStatusType, GetTransactionNotificationStatusTypes>>(transactionNotificationStatusTypeLogic);
container.Register<IRest<Transaction, GetTransactions>>(transactionLogic);
CatchAllHandlers.Add((httpMethod, pathInfo, filePath) => pathInfo.StartsWith("/favicon.ico") ? new FavIconHandler() : null);
var redisLocation = ConfigurationManager.AppSettings["ReddisService"];
Container.Register<IRedisClientsManager>(new PooledRedisClientManager(redisLocation));
var mqService = new RedisMqServer(container.Resolve<IRedisClientsManager>());
var messagingHandlers = new MessageService { Log = new Logger(typeof(MessageService).Name) };
Func<IMessage, IMessage> filterSecureRequests = (message) =>
{
/*
var tag = message.Tag;
if (string.IsNullOrWhiteSpace(tag))
return message;
if (tag.StartsWith("basic ", StringComparison.InvariantCultureIgnoreCase))
{
var creds = Encoding.UTF8.GetString(Convert.FromBase64String(tag.Substring(5)));
var i = creds.IndexOf(':');
var userName = creds.Substring(0, i);
var userPass = creds.Substring(i + 1);
if (userName != SystemConstants.AllowedUser || userPass != SystemConstants.AllowedPass)
{
message.Tag = null;
return message;
}
_currentSessionGuid = Guid.NewGuid();
var sessionKey = userName + "/" + _currentSessionGuid.ToString("N");
SessionContext = new SessionContext { SessionKey = sessionKey, Username = userName };
container.Register(SessionContext);
message.Tag = sessionKey;
return message;
}
message.Tag = null;*/
return message;
};
mqService.RequestFilter = filterSecureRequests;
Func<IMessage<Transaction>, PostResponse<Transaction>> handlePostTransactions = (message) =>
{
var service = new TransactionWebService { Logic = transactionLogic };
var request = new BasicRequest {Message = message, Dto = message.GetBody()};
var response = new BasicResponse(request);
//userRepo.TryAuthenticate()
service.SessionFactory.GetOrCreateSession(request, response);
var session = service.GetSession();
session.UserName = "******";
var results = new PostResponse<Transaction> {Result = (Transaction) service.Post(message.GetBody())};
return results;
};
// Dto Get Operations
mqService.RegisterHandler<GetCurrencyTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), currencyTypeLogic));
mqService.RegisterHandler<GetTransactions>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionLogic));
mqService.RegisterHandler<GetTransactionStatusTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionStatusTypeLogic));
mqService.RegisterHandler<GetTransactionNotificationStatusTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionNotificationStatusTypeLogic));
mqService.RegisterHandler<GetTransactionTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionTypeLogic));
// Dto Post Operations
mqService.RegisterHandler<CurrencyType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), currencyTypeLogic.Post));
mqService.RegisterHandler<Transaction>(handlePostTransactions);
mqService.RegisterHandler<TransactionStatusType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), transactionStatusTypeLogic.Post));
mqService.RegisterHandler<TransactionNotificationStatusType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), transactionNotificationStatusTypeLogic.Post));
mqService.RegisterHandler<TransactionType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), transactionTypeLogic.Post));
// Dto Put Opertations
mqService.RegisterHandler<DeleteCurrencyType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), currencyTypeLogic));
mqService.RegisterHandler<DeleteTransaction>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionLogic));
mqService.RegisterHandler<DeleteTransactionStatusType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionStatusTypeLogic));
mqService.RegisterHandler<DeleteTransactionNotificationStatusType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionNotificationStatusTypeLogic));
mqService.RegisterHandler<DeleteTransactionType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionTypeLogic));
mqService.Start();
}
public void WillSendEmailToGalleryOwner()
{
var from = new MailAddress("*****@*****.**", "too");
var package = new Package
{
PackageRegistration = new PackageRegistration { Id = "smangit" },
Version = "1.42.0.1"
};
var mailSender = new Mock<IMailSender>();
var setting = new GallerySetting { GalleryOwnerName = "NuGet Gallery", GalleryOwnerEmail = "*****@*****.**" };
var messageService = new MessageService(mailSender.Object, setting);
var message = messageService.ReportAbuse(from, package, "Abuse!");
Assert.Equal("*****@*****.**", message.To[0].Address);
Assert.Equal("[NuGet Gallery] Abuse Report for Package 'smangit' Version '1.42.0.1'", message.Subject);
Assert.Contains("Abuse!", message.Body);
Assert.Contains("User too ([email protected]) reports the package 'smangit' version '1.42.0.1' as abusive", message.Body);
}
private void tlvMessages_DoubleClick(object sender, EventArgs e)
{
var clv = (ContainerListView) sender;
var pnt = tlvMessages.PointToClient(MousePosition);
var clvo = clv.GetItemAt(pnt);
if (clvo != null)
{
var subItems = clvo.SubItems;
var id = int.Parse(subItems[7].Text);
var messageService = new MessageService();
var messageDto = messageService.GetById(id);
var frmDetails = new MessageDetails(messageDto);
frmDetails.Show();
}
}
public void DoesNotSendRequestIfUserDoesNotAllowEmails()
{
var to = new User { Username = "******", EmailAddress = "*****@*****.**", EmailAllowed = false };
var from = new User { Username = "******", EmailAddress = "*****@*****.**" };
var mailSender = new Mock<IMailSender>();
mailSender.Setup(s => s.Send(It.IsAny<MailMessage>())).Throws(new InvalidOperationException("Should not be called"));
var setting = new GallerySetting { GalleryOwnerName = "NuGet Gallery", GalleryOwnerEmail = "*****@*****.**" };
var messageService = new MessageService(mailSender.Object, setting);
var package = new PackageRegistration { Id = "CoolStuff" };
var confirmationUrl = "http://example.com/confirmation-token-url";
var message = messageService.SendPackageOwnerRequest(from, to, package, confirmationUrl);
Assert.Null(message);
}
public void SendsPackageOwnerRequestConfirmationUrl()
{
var to = new User { Username = "******", EmailAddress = "*****@*****.**", EmailAllowed = true };
var from = new User { Username = "******", EmailAddress = "*****@*****.**" };
var mailSender = new Mock<IMailSender>();
var setting = new GallerySetting { GalleryOwnerName = "NuGet Gallery", GalleryOwnerEmail = "*****@*****.**" };
var messageService = new MessageService(mailSender.Object, setting);
var package = new PackageRegistration { Id = "CoolStuff" };
var confirmationUrl = "http://example.com/confirmation-token-url";
var message = messageService.SendPackageOwnerRequest(from, to, package, confirmationUrl);
Assert.Equal("*****@*****.**", message.To[0].Address);
Assert.Equal("*****@*****.**", message.From.Address);
Assert.Equal("[NuGet Gallery] The user 'Existing' wants to add you as an owner of the package 'CoolStuff'.", message.Subject);
Assert.Contains(confirmationUrl, message.Body);
Assert.Contains("The user 'Existing' wants to add you as an owner of the package 'CoolStuff'.", message.Body);
}
public void WillSendInstructions()
{
var user = new User { EmailAddress = "*****@*****.**", Username = "******" };
var mailSender = new Mock<IMailSender>();
var setting = new GallerySetting { GalleryOwnerName = "NuGet Gallery", GalleryOwnerEmail = "*****@*****.**" };
var messageService = new MessageService(mailSender.Object, setting);
var message = messageService.SendPasswordResetInstructions(user, "http://example.com/pwd-reset-token-url");
Assert.Equal("*****@*****.**", message.To[0].Address);
Assert.Equal("[NuGet Gallery] Please reset your password.", message.Subject);
Assert.Contains("Click the following link within the next", message.Body);
Assert.Contains("http://example.com/pwd-reset-token-url", message.Body);
}
public void WillSendEmailToNewUser()
{
var to = new MailAddress("*****@*****.**", "too");
var mailSender = new Mock<IMailSender>();
var setting = new GallerySetting { GalleryOwnerName = "NuGet Gallery", GalleryOwnerEmail = "*****@*****.**" };
var messageService = new MessageService(mailSender.Object, setting);
var message = messageService.SendNewAccountEmail(to, "http://example.com/confirmation-token-url");
Assert.Equal("*****@*****.**", message.To[0].Address);
Assert.Equal("[NuGet Gallery] Please verify your account.", message.Subject);
Assert.Contains("http://example.com/confirmation-token-url", message.Body);
}
public BrokerController(MessageService messageService)
{
_messageService = messageService;
}
public void WillSendInstructions()
{
var user = new User { EmailAddress = "*****@*****.**", Username = "******" };
var config = new Mock<IConfiguration>();
config.Setup(c => c.GalleryOwnerEmailAddress).Returns(new MailAddress("NuGet Gallery <*****@*****.**>"));
var mailSender = new Mock<IMailSender>();
var messageService = new MessageService(mailSender.Object, config.Object);
var message = messageService.SendPasswordResetInstructions(user, "http://example.com/pwd-reset-token-url");
Assert.Equal("*****@*****.**", message.To[0].Address);
Assert.Equal("[NuGet Gallery] Please reset your password.", message.Subject);
Assert.Contains("Click the following link within the next", message.Body);
Assert.Contains("http://example.com/pwd-reset-token-url", message.Body);
}
public void WillSendEmailToNewUser()
{
var to = new MailAddress("*****@*****.**", "too");
var config = new Mock<IConfiguration>();
config.Setup(c => c.GalleryOwnerEmailAddress).Returns(new MailAddress("NuGet Gallery <*****@*****.**>"));
var mailSender = new Mock<IMailSender>();
var messageService = new MessageService(mailSender.Object, config.Object);
var message = messageService.SendNewAccountEmail(to, "http://example.com/confirmation-token-url");
Assert.Equal("*****@*****.**", message.To[0].Address);
Assert.Equal("[NuGet Gallery] Please verify your account.", message.Subject);
Assert.Contains("http://example.com/confirmation-token-url", message.Body);
}
