public static void sendDocument(string apiKey, string fileName, string formFieldLayerTemplateKey, string recipient)
{
FileStream file = getTestPdfFile(fileName);
secure.echosign.com.FileInfo[] fileInfos = new secure.echosign.com.FileInfo[1];
fileInfos[0] = new secure.echosign.com.FileInfo(fileName, null, file);
SenderInfo senderInfo = null;
string[] recipients = new string[1];
recipients[0] = recipient;
DocumentCreationInfo documentInfo = new DocumentCreationInfo(
recipients,
testPrefix + Path.GetFileName(file.Name),
testMessage,
fileInfos,
SignatureType.ESIGN,
SignatureFlow.SENDER_SIGNATURE_NOT_REQUIRED
);
if (formFieldLayerTemplateKey != null)
{
secure.echosign.com.FileInfo[] formFieldLayerTemplates = new secure.echosign.com.FileInfo[1];
formFieldLayerTemplates[0] = new secure.echosign.com.FileInfo(formFieldLayerTemplateKey);
documentInfo.formFieldLayerTemplates = formFieldLayerTemplates;
}
DocumentKey[] documentKeys;
documentKeys = ES.sendDocument(apiKey, senderInfo, documentInfo);
Console.WriteLine("Document key is: " + documentKeys[0].documentKey);
}
public void CreateProject(string projectPath, string projectName)
{
IProjectTemplate projectTemplate = (
from template in this.serviceProvider.ProjectManager().TemplateManager.ProjectTemplates
where template.Identifier.Equals("Microsoft.Blend.WPFApplication")
select template).First <IProjectTemplate>();
IProject project = this.serviceProvider.ProjectManager().CreateProjectTemplate(projectPath, projectName, projectTemplate, null).FirstOrDefault <INamedProject>() as IProject;
if (project != null)
{
IDocumentType item = this.serviceProvider.DocumentTypes()[DocumentTypeNamesHelper.Xaml];
ICodeDocumentType codeDocumentType = this.serviceProvider.DocumentTypes().CSharpDocumentType();
List <DocumentCreationInfo> documentCreationInfos = new List <DocumentCreationInfo>();
DocumentCreationInfo documentCreationInfo = new DocumentCreationInfo()
{
DocumentType = item,
TargetPath = Path.Combine(project.ProjectRoot.Path, "TestUserControl.xaml")
};
documentCreationInfos.Add(documentCreationInfo);
DocumentCreationInfo documentCreationInfo1 = new DocumentCreationInfo()
{
DocumentType = codeDocumentType,
TargetPath = Path.Combine(project.ProjectRoot.Path, "TestUserControl.xaml.cs")
};
documentCreationInfos.Add(documentCreationInfo1);
project.AddItems(documentCreationInfos);
project.StartupItem.OpenView(true);
}
}
private bool IsLargeImage(DocumentCreationInfo potentialImage)
{
if (potentialImage.DocumentType is ImageDocumentType)
{
return(this.IsFileLargerThan(this.GetLargeImageThreshold(), potentialImage.SourcePath));
}
return(false);
}
private bool CanOverrideBuildTask(DocumentCreationInfo potentialImage)
{
if (potentialImage.BuildTaskInfo == null)
{
return(!this.MustUseDefaultBuildTask(potentialImage));
}
return(false);
}
public static IProjectItem CreateDesignDataFile(Type type, string dataSourceName, IProjectContext projectContext, bool isDesignTimeCreatable)
{
string path1 = Path.Combine(Path.GetDirectoryName(projectContext.ProjectPath), DataSetContext.SampleData.DataRootFolder);
string str = dataSourceName ?? type.Name;
string path2_1 = str + ".xaml";
string path2 = Path.Combine(path1, path2_1);
int num = 1;
while (File.Exists(path2))
{
string path2_2 = str + num.ToString((IFormatProvider)CultureInfo.InvariantCulture) + ".xaml";
path2 = Path.Combine(path1, path2_2);
++num;
}
string path3 = Path.GetTempFileName() + ".xaml";
IProjectContext projectContext1 = projectContext;
if (!isDesignTimeCreatable)
{
projectContext1 = (IProjectContext)(projectContext as TypeReflectingProjectContext) ?? (IProjectContext) new TypeReflectingProjectContext(projectContext);
}
DocumentContext documentContext = new DocumentContext(projectContext1, (IDocumentLocator) new DocumentLocator(path2), false);
IType type1 = documentContext.TypeResolver.GetType(type);
DocumentNode node = new DesignDataGenerator(type1, (IDocumentContext)documentContext).Build();
try
{
using (StreamWriter text = File.CreateText(path3))
{
using (XamlDocument xamlDocument = new XamlDocument((IDocumentContext)documentContext, (ITypeId)type1, (ITextBuffer) new SimpleTextBuffer(), DocumentEncodingHelper.DefaultEncoding, (IXamlSerializerFilter) new DefaultXamlSerializerFilter()))
new XamlSerializer((IDocumentRoot)xamlDocument, (IXamlSerializerFilter) new DefaultXamlSerializerFilter()).Serialize(node, (TextWriter)text);
}
BuildTaskInfo buildTaskInfo = new BuildTaskInfo(DocumentContextHelper.DesignDataBuildTask, (IDictionary <string, string>) new Dictionary <string, string>());
DocumentCreationInfo creationInfo = new DocumentCreationInfo()
{
BuildTaskInfo = buildTaskInfo,
TargetFolder = path1,
TargetPath = path2,
SourcePath = path3,
CreationOptions = CreationOptions.SilentlyOverwrite | CreationOptions.SilentlyOverwriteReadOnly | CreationOptions.DoNotSelectCreatedItems | CreationOptions.DoNotSetDefaultImportPath
};
return(((IProject)projectContext.GetService(typeof(IProject))).AddItem(creationInfo));
}
finally
{
try
{
File.Delete(path3);
}
catch
{
}
}
}
/// <summary>
/// Sends the agreement.
/// </summary>
/// <param name="dci">The dci.</param>
/// <returns></returns>
public async Task <EchoSignSendAgreementResponse> SendAgreement(DocumentCreationInfo dci)
{
var fileInfo = dci.fileInfos[0];
var docId = await UploadTransientDocumentAndGetId(fileInfo.fileName, fileInfo.file);
var httpContent = new EchoSignSendAgreementRequest(dci)
.WithTransientDocId(docId)
.BuildContent();
var accessToken = await GetAccessToken();
var response = await Post <EchoSignSendAgreementResponse>(agreementsEndpoint, httpContent, accessToken);
return(response);
}
public Microsoft.Expression.Extensibility.Project.IProjectItem AddItem(string documentItemPath, string itemType)
{
if (!this.IsValid)
{
return(null);
}
Microsoft.Expression.Project.IProject project = this.project;
DocumentCreationInfo documentCreationInfo = new DocumentCreationInfo()
{
SourcePath = documentItemPath,
CreationOptions = CreationOptions.None,
BuildTaskInfo = new BuildTaskInfo(itemType, null)
};
return(Microsoft.Expression.Extensibility.Project.ProjectItem.FromProjectItem(this, project.AddItem(documentCreationInfo)));
}
/// <summary>
/// Converts to json string.
/// </summary>
/// <param name="dci">The dci.</param>
/// <returns></returns>
private string ConvertToJsonString(DocumentCreationInfo dci)
{
var createInfo = new EchoSignDocumentCreateInfo {
name = dci.name,
signatureType = "ESIGN",
daysUntilSigningDeadline = dci.daysUntilSigningDeadline ?? 7,
reminderFrequency = dci.reminderFrequency.HasValue ? dci.reminderFrequency.Value.ToString() : "DAILY_UNTIL_SIGNED",
signatureFlow = dci.signatureFlow.HasValue ? dci.signatureFlow.Value.ToString() : "PARALLEL",
recipientSetInfos = CreateRecipientSetInfo(dci.recipients)
.ToArray(),
fileInfos = new[] {
CreateFileInfo()
}
};
var agreementCreation = new EchoSignAgreementCreationInfo {
documentCreationInfo = createInfo
};
return(JsonConvert.SerializeObject(agreementCreation));
}
protected override bool CreateProjectItem()
{
IProjectItem projectItem;
IProject project = this.SelectedProjectOrNull();
if (project == null)
{
return(false);
}
IDocumentType item = base.Services.DocumentTypes()[DocumentTypeNamesHelper.Folder];
string str = this.ProjectManager().TargetFolderForProject(project);
string availableFilePath = ProjectPathHelper.GetAvailableFilePath(item.DefaultFileName, str, project);
Directory.CreateDirectory(availableFilePath);
try
{
List <DocumentCreationInfo> documentCreationInfos = new List <DocumentCreationInfo>();
DocumentCreationInfo documentCreationInfo = new DocumentCreationInfo()
{
DocumentType = item,
TargetPath = availableFilePath
};
documentCreationInfos.Add(documentCreationInfo);
projectItem = project.AddItems(documentCreationInfos).FirstOrDefault <IProjectItem>();
}
catch
{
Directory.Delete(availableFilePath);
throw;
}
if (projectItem != null)
{
base.Services.SetSelection(projectItem);
base.Services.CommandService().Execute("Project_RenameProjectItem", CommandInvocationSource.Internally);
}
return(projectItem != null);
}
private EchoSignSendResultCode SendOne(
Template oTemplate,
byte[] oFileContent,
List <Person> oAddressee,
int nCustomerID,
long cashRequestID,
int nTemplateID,
bool bSentToCustomer,
EchoSignSendResult result
)
{
var oRecipients = oAddressee.Select(oPerson => new RecipientInfo {
email = oPerson.Email,
role = RecipientRole.SIGNER,
}).ToArray();
var sAllRecipients = string.Join(", ", oRecipients.Select(r => r.email));
var fi = new FileInfo {
fileName = oTemplate.FileName,
mimeType = oTemplate.MimeType,
file = oFileContent ?? oTemplate.FileContent,
};
var dci = new DocumentCreationInfo {
name = oTemplate.DocumentName,
signatureType = SignatureType.ESIGN,
reminderFrequency = this.reminderFrequency,
signatureFlow = SignatureFlow.PARALLEL,
daysUntilSigningDeadline = this.deadline,
recipients = oRecipients,
fileInfos = new[] { fi },
};
this.log.Debug("Sending a document '{0}' to {1}...", oTemplate.DocumentName, sAllRecipients);
DocumentKey[] aryResult;
try {
if (this.isUseRestApi)
{
var response = this.restClient.SendAgreement(dci).Result;
if (string.IsNullOrEmpty(response.agreementId))
{
throw new Exception("error sending when sent agreement");
}
DocumentKey documentKey = new DocumentKey {
documentKey = response.agreementId
};
aryResult = new[] {
documentKey
};
}
else
{
aryResult = this.echoSign.sendDocument(this.apiKey, null, dci);
}
} catch (Exception e) {
string msg = string.Format(
"Something went exceptionally terrible while sending a document '{0}' to {1}.",
oTemplate.DocumentName,
sAllRecipients
);
this.log.Warn(e, msg);
result.AddErrorMessage(msg);
return(EchoSignSendResultCode.Fail);
} // try
if (aryResult.Length != 1)
{
const string msg = "Failed to send documents for signing.";
this.log.Alert(msg);
result.AddErrorMessage(msg);
}
else
{
this.log.Debug("Sending result: document key is '{0}'.", aryResult[0].documentKey);
var sp = new SpSaveEsignSent(this.db, this.log)
{
CustomerID = nCustomerID,
CashRequestID = cashRequestID,
Directors = oAddressee.Where(x => x.PersonType == PersonType.Director).Select(x => x.ID).ToList(),
ExperianDirectors = oAddressee
.Where(x => x.PersonType == PersonType.ExperianDirector)
.Select(x => x.ID).ToList(),
DocumentKey = aryResult[0].documentKey,
SentToCustomer = bSentToCustomer,
TemplateID = nTemplateID,
};
sp.ExecuteNonQuery();
} // if
return(EchoSignSendResultCode.Success);
} // SendOne
/// <summary>
/// Initializes a new instance of the <see cref="EchoSignSendAgreementRequest"/> class.
/// </summary>
/// <param name="dci">The dci.</param>
public EchoSignSendAgreementRequest(DocumentCreationInfo dci)
{
this.dci = dci;
}
public IEnumerable <IProjectItem> CreateProjectItems(string name, string targetFolder, IProject project, IEnumerable <TemplateArgument> templateArguments, CreationOptions creationOptions, out List <IProjectItem> itemsToOpen, IServiceProvider serviceProvider)
{
Uri uri;
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name");
}
ICodeDocumentType codeDocumentType = base.GetCodeDocumentType(serviceProvider);
if (templateArguments != null)
{
templateArguments = templateArguments.Concat <TemplateArgument>(TemplateManager.GetDefaultArguments(serviceProvider.ExpressionInformationService()));
}
else
{
templateArguments = TemplateManager.GetDefaultArguments(serviceProvider.ExpressionInformationService());
}
IEnumerable <IProjectItem> projectItems = Enumerable.Empty <IProjectItem>();
itemsToOpen = new List <IProjectItem>();
using (ProjectPathHelper.TemporaryDirectory temporaryDirectory = new ProjectPathHelper.TemporaryDirectory(true))
{
Uri uri1 = new Uri(Microsoft.Expression.Framework.Documents.PathHelper.EnsurePathEndsInDirectorySeparator(temporaryDirectory.Path));
List <DocumentCreationInfo> documentCreationInfos = new List <DocumentCreationInfo>();
List <string> strs = new List <string>();
bool flag = false;
foreach (VSTemplateTemplateContentProjectItem templateProjectItem in this.TemplateProjectItems)
{
if (!templateProjectItem.OpenInEditorSpecified)
{
continue;
}
flag = true;
break;
}
bool flag1 = false;
string str = CodeGenerator.MakeSafeIdentifier(codeDocumentType, project.DocumentReference.DisplayNameShort, flag1);
bool flag2 = true;
string str1 = CodeGenerator.MakeSafeIdentifier(codeDocumentType, project.DocumentReference.DisplayNameShort, flag2);
TemplateArgument templateArgument = new TemplateArgument("safeprojectname", str);
TemplateArgument templateArgument1 = new TemplateArgument("safeprojectname", str1);
TemplateArgument templateArgument2 = new TemplateArgument("assemblyname", project.DocumentReference.DisplayNameShort);
TemplateArgument templateArgument3 = new TemplateArgument("safeassemblyname", project.DocumentReference.DisplayNameShort.Replace(' ', '\u005F'));
foreach (VSTemplateTemplateContentProjectItem vSTemplateTemplateContentProjectItem in this.TemplateProjectItems)
{
string targetFileName = vSTemplateTemplateContentProjectItem.TargetFileName;
if (string.IsNullOrEmpty(targetFileName))
{
targetFileName = vSTemplateTemplateContentProjectItem.Value;
}
TemplateArgument[] templateArgumentArray = new TemplateArgument[] { new TemplateArgument("fileinputname", Path.GetFileNameWithoutExtension(name)), new TemplateArgument("fileinputextension", Path.GetExtension(name)) };
IEnumerable <TemplateArgument> templateArguments1 = templateArgumentArray;
targetFileName = TemplateParser.ReplaceTemplateArguments(targetFileName, templateArguments1);
templateArguments1 = templateArguments1.Concat <TemplateArgument>(templateArguments);
bool flag3 = Path.GetExtension(vSTemplateTemplateContentProjectItem.Value).Equals(codeDocumentType.DefaultFileExtension, StringComparison.OrdinalIgnoreCase);
string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(Microsoft.Expression.Framework.Documents.PathHelper.GetFileOrDirectoryName(targetFileName));
if (serviceProvider.DocumentTypeManager().DocumentTypes[DocumentTypeNamesHelper.Xaml].IsDocumentTypeOf(fileNameWithoutExtension))
{
fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileNameWithoutExtension);
}
string str2 = CodeGenerator.MakeSafeIdentifier(codeDocumentType, fileNameWithoutExtension, flag3);
IEnumerable <TemplateArgument> templateArguments2 = templateArguments1;
TemplateArgument[] templateArgumentArray1 = new TemplateArgument[] { new TemplateArgument("rootnamespace", project.DefaultNamespaceName), new TemplateArgument("projectname", project.DocumentReference.DisplayNameShort), templateArgument2, templateArgument3, null, null, null, null };
templateArgumentArray1[4] = (flag3 ? templateArgument1 : templateArgument);
templateArgumentArray1[5] = new TemplateArgument("safeitemname", str2);
templateArgumentArray1[6] = new TemplateArgument("safeitemrootname", str2);
templateArgumentArray1[7] = new TemplateArgument("culture", (string.IsNullOrEmpty(project.UICulture) ? CultureInfo.CurrentUICulture.ToString() : project.UICulture));
templateArguments1 = templateArguments2.Concat <TemplateArgument>(templateArgumentArray1);
try
{
uri = base.ResolveFileUri(targetFileName, uri1);
}
catch (UriFormatException uriFormatException)
{
continue;
}
IDocumentType documentType = project.GetDocumentType(targetFileName);
foreach (IDocumentType documentType1 in serviceProvider.DocumentTypeManager().DocumentTypes)
{
if (vSTemplateTemplateContentProjectItem.SubType != documentType1.Name)
{
continue;
}
documentType = documentType1;
}
if (!base.CreateFile(vSTemplateTemplateContentProjectItem.Value, base.TemplateLocation, uri, vSTemplateTemplateContentProjectItem.ReplaceParameters, templateArguments1))
{
continue;
}
string str3 = ProjectItemTemplate.AdjustTargetFolder(targetFolder, uri1.LocalPath, uri.LocalPath);
DocumentCreationInfo documentCreationInfo = new DocumentCreationInfo()
{
SourcePath = uri.LocalPath,
TargetFolder = str3,
DocumentType = documentType,
CreationOptions = creationOptions
};
documentCreationInfos.Add(documentCreationInfo);
if (!flag)
{
if (strs.Count > 0)
{
continue;
}
strs.Add(Path.Combine(str3, Path.GetFileName(uri.LocalPath)));
}
else
{
if (!vSTemplateTemplateContentProjectItem.OpenInEditor)
{
continue;
}
strs.Add(Path.Combine(str3, Path.GetFileName(uri.LocalPath)));
}
}
if (documentCreationInfos.Count > 0)
{
projectItems = project.AddItems(documentCreationInfos);
}
if (projectItems.Any <IProjectItem>())
{
for (int i = 0; i < strs.Count; i++)
{
IProjectItem projectItem = projectItems.FirstOrDefault <IProjectItem>((IProjectItem item) => item.DocumentReference.Path.Equals(strs[i], StringComparison.OrdinalIgnoreCase));
if (projectItem != null)
{
itemsToOpen.Add(projectItem);
}
}
projectItems = projectItems.Concat <IProjectItem>(this.AddAssemblies(project));
}
}
if (base.BuildOnLoad)
{
IProjectManager projectManager = serviceProvider.ProjectManager();
IProjectBuildContext activeBuildTarget = projectManager.ActiveBuildTarget;
projectManager.BuildManager.Build(activeBuildTarget, null, true);
KnownProjectBase knownProjectBase = project as KnownProjectBase;
if (knownProjectBase != null)
{
knownProjectBase.CheckForChangedOrDeletedItems();
}
}
return(projectItems);
}
private bool MustUseDefaultBuildTask(DocumentCreationInfo potentialImage)
{
return((potentialImage.CreationOptions & CreationOptions.AlwaysUseDefaultBuildTask) == CreationOptions.AlwaysUseDefaultBuildTask);
}
private bool ItemAlreadyExistsInProject(DocumentCreationInfo potentialImage, IProject project)
{
return(project.FindItem(DocumentReference.Create(potentialImage.TargetPath)) != null);
}
