public static string GetAccountId()
{
var appSettings = System.Configuration.ConfigurationManager.AppSettings;
string username = appSettings["docusignDeveloperEmail"] ?? "*****@*****.**";
string password = appSettings["docusignPassword"] ?? "epercic";
string integratorKey = appSettings["docusignIntegratorKey"] ?? "a2dced5d-bebe-4b70-803e-bbbb70ecf7cb";
string authHeader = "{\"Username\":\"" + username + "\", \"Password\":\"" + password + "\", \"IntegratorKey\":\"" + integratorKey + "\"}";
Configuration.AddDefaultHeader("X-DocuSign-Authentication", authHeader);
// the authentication api uses the apiClient (and X-DocuSign-Authentication header) that are set in Configuration object
AuthenticationApi authApi = new AuthenticationApi(Configuration);
LoginInformation loginInfo = authApi.Login();
// find the default account for this user
foreach (LoginAccount loginAccount in loginInfo.LoginAccounts)
{
if (loginAccount.IsDefault == "true")
{
return(loginAccount.AccountId);
}
}
return(null);
}
public static string GetAccountId()
{
var appSettings = System.Configuration.ConfigurationManager.AppSettings;
string username = appSettings["docusignDeveloperEmail"] ?? "*****@*****.**";
string password = appSettings["docusignPassword"] ?? "N#ewport4331";
string integratorKey = appSettings["docusignIntegratorKey"] ?? "4ed5be53-a1e4-49d4-80bd-563d4635eb9d";
string authHeader = "{\"Username\":\"" + username + "\", \"Password\":\"" + password + "\", \"IntegratorKey\":\"" + integratorKey + "\"}";
Configuration.AddDefaultHeader("X-DocuSign-Authentication", authHeader);
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
// the authentication api uses the apiClient (and X-DocuSign-Authentication header) that are set in Configuration object
AuthenticationApi authApi = new AuthenticationApi(Configuration);
LoginInformation loginInfo = authApi.Login();
// find the default account for this user
foreach (LoginAccount loginAccount in loginInfo.LoginAccounts)
{
if (loginAccount.IsDefault == "true")
{
return(loginAccount.AccountId);
}
}
return(null);
}
public string GetAccountID()
{
#region auth_details
string integratorKey = ConfigurationManager.AppSettings["IntegratorKey"];
string email = ConfigurationManager.AppSettings["DocuSignUserEmail"];
string password = ConfigurationManager.AppSettings["DocuSignPassword"];
string authHeader = "{\"Username\":\"" + email + "\", \"Password\":\"" + password + "\", \"IntegratorKey\":\"" + integratorKey + "\"}";
#endregion
DocuSign.eSign.Client.Configuration.Default.AddDefaultHeader("X-DocuSign-Authentication", authHeader);
#region attemptlogin
ApiClient client = new ApiClient(basePath: "https://demo.docusign.net/restapi");
DocuSign.eSign.Client.Configuration configHeader = new DocuSign.eSign.Client.Configuration(client);
configHeader.AddDefaultHeader("X-DocuSign-Authentication", authHeader);
AuthenticationApi authApi = new AuthenticationApi(configHeader);
LoginInformation loginInfo = authApi.Login();
#endregion
return(loginInfo.LoginAccounts[0].AccountId);
}
public void LoginTest()
{
// configure the ApiClient for the DocuSign site and authentictaion needed.
Utils.ConfigureApiClient();
AuthenticationApi authApi = new AuthenticationApi();
AuthenticationApi.LoginOptions options = new AuthenticationApi.LoginOptions();
options.apiPassword = "******";
options.includeAccountIdGuid = "true";
LoginInformation loginInfo = authApi.Login(options);
Assert.IsNotNull(loginInfo.LoginAccounts);
// find the default account for this user
foreach (LoginAccount loginAcct in loginInfo.LoginAccounts)
{
if (loginAcct.IsDefault == "true")
{
TestConfig.AccountId = loginAcct.AccountId;
break;
}
}
Assert.IsNotNull(TestConfig.AccountId);
}
public void LegacyLoginTest()
{
string authHeader = "{\"Username\":\"" + testConfig.Username + "\", \"Password\":\"" + testConfig.Password + "\", \"IntegratorKey\":\"" + testConfig.IntegratorKey + "\"}";
testConfig.ApiClient = new ApiClient(testConfig.Host);
if (testConfig.ApiClient.Configuration.DefaultHeader.ContainsKey("X-DocuSign-Authentication"))
{
testConfig.ApiClient.Configuration.DefaultHeader.Remove("X-DocuSign-Authentication");
}
testConfig.ApiClient.Configuration.AddDefaultHeader("X-DocuSign-Authentication", authHeader);
// the authentication api uses the apiClient (and X-DocuSign-Authentication header) that are set in Configuration object
AuthenticationApi authApi = new AuthenticationApi(testConfig.ApiClient.Configuration);
LoginInformation loginInfo = authApi.Login();
Assert.IsNotNull(loginInfo);
Assert.IsNotNull(loginInfo.LoginAccounts);
// find the default account for this user
foreach (LoginAccount loginAcct in loginInfo.LoginAccounts)
{
if (loginAcct.IsDefault == "true" || testConfig.AccountId == null)
{
testConfig.AccountId = loginAcct.AccountId;
string[] separatingStrings = { "/v2" };
// Update ApiClient with the new base url from login call
testConfig.ApiClient = new ApiClient(loginAcct.BaseUrl.Split(separatingStrings, StringSplitOptions.RemoveEmptyEntries)[0]);
break;
}
}
Assert.IsNotNull(testConfig.AccountId);
}
public static string GetAccountId()
{
var appSettings = System.Configuration.ConfigurationManager.AppSettings;
string username = appSettings["docusignDeveloperEmail"] ?? "*****@*****.**";
string password = appSettings["docusignPassword"] ?? "gopala";
string integratorKey = appSettings["docusignIntegratorKey"] ?? "TEST-5913deaf-c9d9-4d6b-a8a0-2d7ca76db2f5";
string authHeader = "{\"Username\":\"" + username + "\", \"Password\":\"" + password + "\", \"IntegratorKey\":\"" + integratorKey + "\"}";
Configuration.AddDefaultHeader("X-DocuSign-Authentication", authHeader);
// the authentication api uses the apiClient (and X-DocuSign-Authentication header) that are set in Configuration object
AuthenticationApi authApi = new AuthenticationApi(Configuration);
LoginInformation loginInfo = authApi.Login();
// find the default account for this user
foreach (LoginAccount loginAccount in loginInfo.LoginAccounts)
{
if (loginAccount.IsDefault == "true")
{
return(loginAccount.AccountId);
}
}
return(null);
}
public void JwtLoginTest()
{
testConfig.ApiClient = new ApiClient(testConfig.Host);
testConfig.ApiClient.ConfigureJwtAuthorizationFlow(testConfig.IntegratorKey, testConfig.UserId, testConfig.OAuthBasePath, testConfig.PrivateKeyFilename, testConfig.ExpiresInHours);
// the authentication api uses the apiClient (and X-DocuSign-Authentication header) that are set in Configuration object
AuthenticationApi authApi = new AuthenticationApi(testConfig.ApiClient.Configuration);
LoginInformation loginInfo = authApi.Login();
Assert.IsNotNull(loginInfo);
Assert.IsNotNull(loginInfo.LoginAccounts);
// find the default account for this user
foreach (LoginAccount loginAcct in loginInfo.LoginAccounts)
{
if (loginAcct.IsDefault == "true" || testConfig.AccountId == null)
{
testConfig.AccountId = loginAcct.AccountId;
string[] separatingStrings = { "/v2" };
// Update ApiClient with the new base url from login call
testConfig.ApiClient = new ApiClient(loginAcct.BaseUrl.Split(separatingStrings, StringSplitOptions.RemoveEmptyEntries)[0]);
//testConfig.Configuration = config;
break;
}
}
Assert.IsNotNull(testConfig.AccountId);
}
/// <summary>
/// Login this instance.
/// </summary>
public static void Login()
{
var username = Settings.Default.Username;
var password = Settings.Default.Password;
var integratorKey = Settings.Default.IntegratorKey;
var restUrl = Settings.Default.RestUrl;
// initialize client for desired environment (for production change to www)
var apiClient = new ApiClient(restUrl);
Configuration.Default.ApiClient = apiClient;
// configure 'X-DocuSign-Authentication' header
var authHeader = "{\"Username\":\"" + username + "\", \"Password\":\"" + password +
"\", \"IntegratorKey\":\"" + integratorKey + "\"}";
Configuration.Default.AddDefaultHeader("X-DocuSign-Authentication", authHeader);
// we will retrieve this from the login API call
string accountId = null;
/////////////////////////////////////////////////////////////////
// STEP 1: LOGIN API
/////////////////////////////////////////////////////////////////
// login call is available in the authentication api
var authApi = new AuthenticationApi();
var loginInfo = authApi.Login();
// parse the first account ID that is returned (user might belong to multiple accounts)
accountId = loginInfo.LoginAccounts[0].AccountId;
AccountId = accountId;
}
public string loginApi(string usr, string pwd)
{
usr = "******";
pwd = "Cns@12345";
// we set the api client in global config when we configured the client
ApiClient apiClient = Configuration.Default.ApiClient;
string authHeader = "{\"Username\":\"" + usr + "\", \"Password\":\"" + pwd + "\", \"IntegratorKey\":\"" + INTEGRATOR_KEY + "\"}";
Configuration.Default.AddDefaultHeader("X-DocuSign-Authentication", authHeader);
// we will retrieve this from the login() results
string accountId = null;
// the authentication api uses the apiClient (and X-DocuSign-Authentication header) that are set in Configuration object
AuthenticationApi authApi = new AuthenticationApi();
LoginInformation loginInfo = authApi.Login();
// find the default account for this user
foreach (DocuSign.eSign.Model.LoginAccount loginAcct in loginInfo.LoginAccounts)
{
if (loginAcct.IsDefault == "true")
{
accountId = loginAcct.AccountId;
break;
}
}
if (accountId == null)
{ // if no default found set to first account
accountId = loginInfo.LoginAccounts[0].AccountId;
}
return(accountId);
}
public static string loginApi(string user, string password)
{
ApiClient apiClient = Configuration.Default.ApiClient;
string integratorKey = System.Configuration.ConfigurationManager.AppSettings["INTEGRATOR_KEY"];
string authHeader = $"{{\"Username\":\"{user}\",\"Password\":\"{password}\",\"IntegratorKey\":\"{integratorKey}\"}}";
Configuration.Default.AddDefaultHeader(DocuSignConstants.DocuSignHeader, authHeader);
string accountId = null;
AuthenticationApi authApi = new AuthenticationApi();
LoginInformation loginInfo = authApi.Login();
foreach (LoginAccount loginAcct in loginInfo.LoginAccounts)
{
if (loginAcct.IsDefault == "true")
{
accountId = loginAcct.AccountId;
break;
}
}
if (accountId == null && loginInfo.LoginAccounts.Count > 0)
{
accountId = loginInfo.LoginAccounts[0].AccountId;
}
return(accountId);
}
public void OAuthAuthorizationCodeFlowTest()
{
// Make an API call with the token
ApiClient apiClient = new ApiClient(BaseUrl);
DocuSign.eSign.Client.Configuration.Default.ApiClient = apiClient;
// Initiate the browser session to the Authentication server
// so the user can login.
string accountServerAuthUrl = apiClient.GetAuthorizationUri(client_id, redirect_url, true, stateOptional);
System.Diagnostics.Process.Start(accountServerAuthUrl);
WaitForCallbackEvent = new ManualResetEvent(false);
// Launch a self-hosted web server to accepte the redirect_url call
// after the user finishes authentication.
using (WebApp.Start <Startup>("http://localhost:3000"))
{
Trace.WriteLine("WebServer Running. Waiting for access_token...");
// This waits for the redirect_url to be received in the REST controller
// (see classes below) and then sleeps a short time to allow the response
// to be returned to the web browser before the server session ends.
WaitForCallbackEvent.WaitOne(60000, false);
Thread.Sleep(1000);
}
Assert.IsNotNull(AccessCode);
string accessToken = apiClient.GetOAuthToken(client_id, client_secret, true, AccessCode);
Assert.IsNotNull(accessToken);
Trace.WriteLine("Access_token: " + accessToken);
// we will retrieve this from the login API call
string accountId = null;
/////////////////////////////////////////////////////////////////
// STEP 1: LOGIN API
/////////////////////////////////////////////////////////////////
// login call is available in the authentication api
AuthenticationApi authApi = new AuthenticationApi();
LoginInformation loginInfo = authApi.Login();
// parse the first account ID that is returned (user might belong to multiple accounts)
accountId = loginInfo.LoginAccounts[0].AccountId;
// Update ApiClient with the new base url from login call
apiClient = new ApiClient(loginInfo.LoginAccounts[0].BaseUrl);
/////////////////////////////////////////////////////////////////
// STEP 2: CREATE ACCOUNTS API
/////////////////////////////////////////////////////////////////
AccountsApi accountsApi = new AccountsApi();
AccountInformation accountInformation = accountsApi.GetAccountInformation(accountId);
Trace.WriteLine(accountInformation.ToString());
}
private void ConfigureApiClientAuth_OldMethod(ApiClient apiClient)
{
var username = this.Configuration["Docusign:username"];
var password = this.Configuration["Docusign:password"];
var integratorKey = this.Configuration["Docusign:clientId"];
var authHeader = $"{{\"Username\":\"{username}\", \"Password\":\"{password}\", \"IntegratorKey\":\"{integratorKey}\"}}";
apiClient.Configuration.AddDefaultHeader("X-DocuSign-Authentication", authHeader);
var authApi = new AuthenticationApi();
authApi.Login();
}
public void Connect()
{
_client = new HttpPilotClient(_settings.ServerUrl);
_client.Connect(false);
ServerApi = _client.GetServerApi(new NullableServerCallback());
AuthenticationApi = _client.GetAuthenticationApi();
AuthenticationApi.Login(_settings.DbName, _settings.Login, _settings.Password, false, _settings.LicenseCode);
var dataBaseInfo = ServerApi.OpenDatabase();
PersonId = dataBaseInfo.Person.Id;
FileArchiveApi = _client.GetFileArchiveApi();
}
public static string InitializeDocuSignAPI()
{
try
{
//Get Config settings from App.config
DocuSignConfig configSettings = new DocuSignConfig();
string userName = configSettings.DOCUSIGN_USERNAME;
string password = configSettings.DOCUSIGN_PASSWORD;
string integratorKey = configSettings.DOCUSIGN_IK;
// initialize client for desired environment (for production change to www)
ApiClient apiClient = new ApiClient("https://demo.docusign.net/restapi");
eSign.Client.Configuration.Default.ApiClient = apiClient;
// configure 'X-DocuSign-Authentication' header
string authHeader = "{\"Username\":\"" + userName + "\", \"Password\":\"" + password + "\", \"IntegratorKey\":\"" + integratorKey + "\"}";
eSign.Client.Configuration.Default.AddDefaultHeader("X-DocuSign-Authentication", authHeader);
// we will retrieve this from the login API call
string accountId = null;
// login call is available in the authentication api
AuthenticationApi authApi = new AuthenticationApi();
LoginInformation loginInfo = authApi.Login();
// parse the first account ID that is returned (user might belong to multiple accounts)
accountId = loginInfo.LoginAccounts[0].AccountId;
// Update ApiClient with the new base url from login call, but separate string to extract the base path
string baseUrl = loginInfo.LoginAccounts[0].BaseUrl;
string[] separator = new string[] { "/restapi" };
string basePath = baseUrl.Split(separator, StringSplitOptions.None)[0] + "/restapi";
apiClient = new ApiClient(basePath);
//IMPORTANT: Reassign apiClient object - if this isn't done, the call will fail in production
eSign.Client.Configuration.Default.ApiClient = apiClient;
return(accountId);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
throw ex;
}
}
public DocuSignClient(DocuSignCredentials credentials)
{
//initialize client for desired environment (for production change to www)
var apiClient = new ApiClient("https://demo.docusign.net/restapi");
// configure 'X-DocuSign-Authentication' header
var authHeader = "{\"Username\":\"" + credentials.Username + "\", \"Password\":\"" + credentials.Password + "\", \"IntegratorKey\":\"" + credentials.IntegratorKey + "\"}";
Configuration.Default.AddDefaultHeader("X-DocuSign-Authentication", authHeader);
// login call is available in the authentication api
var authApi = new AuthenticationApi();
var loginInfo = authApi.Login();
// parse the first account ID that is returned (user might belong to multiple accounts)
this.AccountId = loginInfo.LoginAccounts[0].AccountId;
}
static void Main(string[] args)
{
string username = "******";
string password = "******";
string integratorKey = "3b9fa7cc-dd91-468a-925d-056ee392643a";
ApiClient apiClient = new ApiClient("https://demo.docusign.net/restapi");
Configuration.Default.ApiClient = apiClient;
string authHeader = "{\"Username\":\"" + username + "\", \"Password\":\"" + password + "\",\"IntegratorKey\":\"" + integratorKey + "\"}";
Configuration.Default.AddDefaultHeader("X-DocuSign-Authentication", authHeader);
string accountid = null;
AuthenticationApi authApi = new AuthenticationApi();
LoginInformation loginInfo = authApi.Login();
accountid = loginInfo.LoginAccounts[0].AccountId;
EnvelopeDefinition envDef = new EnvelopeDefinition();
envDef.EmailSubject = "[DocuSign C# SDK] - Sample Signature Request";
envDef.TemplateId = "";
TemplateRole tRole = new TemplateRole();
tRole.Email = "*****@*****.**";
tRole.Name = "Chumani";
tRole.RoleName = "Junior Developer";
List <TemplateRole> rolesList = new List <TemplateRole>()
{
tRole
};
envDef.TemplateRoles = rolesList;
envDef.Status = "sent";
EnvelopesApi envelopesApi = new EnvelopesApi();
EnvelopeSummary envelopeSummary = envelopesApi.CreateEnvelope(accountid, envDef);
}
// POST api/account/{requestType}/
public HttpResponseMessage PostRequest(string id, LoginRequest data)
{
HttpResponseMessage response;
switch (id)
{
case "login":
LoginRequest loginRequest = (LoginRequest)data;
var isSuccess = authenticationApi.Login(loginRequest.MobileNo, loginRequest.Password);
response = Request.CreateResponse(HttpStatusCode.OK, isSuccess);
break;
default:
response = Request.CreateErrorResponse(HttpStatusCode.BadRequest, new HttpError("Invalid request type!!!"));
break;
}
return(response);
}
public void Connect()
{
_client.Connect();
ServerApi = _client.GetServerApi(new NullableServerCallback());
AuthenticationApi = _client.GetAuthenticationApi();
AuthenticationApi.Login(_settings.DbName, _settings.Login, _settings.Password, false, 100);
ServerApi.OpenDatabase();
var people = ServerApi.LoadPeople();
var person = people.FirstOrDefault(p => !p.IsDeleted && p.Login == _settings.Login);
if (person != null)
{
PersonId = person.Id;
}
FileArchiveApi = _client.GetFileArchiveApi();
}
public DocuSignApiConfiguration SetUp(DocuSignAuthTokenDTO docuSignAuthDTO)
{
string baseUrl = string.Empty;
string integratorKey = string.Empty;
//create configuration for future api calls
if (docuSignAuthDTO.IsDemoAccount)
{
integratorKey = CloudConfigurationManager.GetSetting("DocuSignIntegratorKey_DEMO");
baseUrl = CloudConfigurationManager.GetSetting("environment_DEMO") + "restapi/";
}
else
{
integratorKey = CloudConfigurationManager.GetSetting("DocuSignIntegratorKey");
baseUrl = docuSignAuthDTO.Endpoint.Replace("v2/accounts/" + docuSignAuthDTO.AccountId.ToString(), "");
}
ApiClient apiClient = new ApiClient(baseUrl);
string authHeader = "bearer " + docuSignAuthDTO.ApiPassword;
Configuration conf = new Configuration(apiClient);
conf.AddDefaultHeader("Authorization", authHeader);
DocuSignApiConfiguration result = new DocuSignApiConfiguration()
{
AccountId = docuSignAuthDTO.AccountId, Configuration = conf
};
if (string.IsNullOrEmpty(docuSignAuthDTO.AccountId)) //we deal with and old token, that don't have accountId yet
{
AuthenticationApi authApi = new AuthenticationApi(conf);
try
{
LoginInformation loginInfo = authApi.Login();
result.AccountId = loginInfo.LoginAccounts[0].AccountId; //it seems that althought one DocuSign account can have multiple users - only one is returned, the one that oAuth token was created for
}
catch (Exception ex)
{
throw new AuthorizationTokenExpiredOrInvalidException();
}
}
return(result);
}
private void GetDocuSignAccountId()
{
if (string.IsNullOrWhiteSpace(this.Username) || string.IsNullOrWhiteSpace(this.Password) || string.IsNullOrWhiteSpace(this.IntegratorKey))
{
throw new ArgumentException("No se pudo recuperar las credenciales de docuSign");
}
// configure 'X-DocuSign-Authentication' header
var authHeader = "{\"Username\":\"" + this.Username + "\", \"Password\":\"" + this.Password +
"\", \"IntegratorKey\":\"" + this.IntegratorKey + "\"}";
Configuration.Default.AddDefaultHeader("X-DocuSign-Authentication", authHeader);
// login call is available in the authentication api
var authApi = new AuthenticationApi();
var loginInfo = authApi.Login();
// parse the first account ID that is returned (user might belong to multiple accounts)
this.AccountId = loginInfo.LoginAccounts[0].AccountId;
}
/// <summary>
/// Init DocuSign ApiClient
/// </summary>
/// <param name="senderUsername"></param>
/// <param name="senderPassword"></param>
/// <returns></returns>
public static LoginInformation GetDocuSignApiClient(string senderUsername, string senderPassword, string senderIntegratorKey)
{
//bool loggedIn = loginInfo.LoginAccounts.Where(a => a.UserName == senderUsername && a.ApiPassword == senderPassword)
if (loginInfo == null)
{
var apiClient = new DocuSign.eSign.Client.ApiClient(basePath);
// set client in global config so we don't need to pass it to each API object
DocuSign.eSign.Client.Configuration.Default.ApiClient = apiClient;
string authHeader = "{\"Username\":\"" + senderUsername + "\", \"Password\":\"" + senderPassword + "\", \"IntegratorKey\":\"" + senderIntegratorKey + "\"}";
DocuSign.eSign.Client.Configuration.Default.AddDefaultHeader("X-DocuSign-Authentication", authHeader);
//2 the authentication api uses the apiClient (and X-DocuSign-Authentication header) that are set in Configuration object
AuthenticationApi authApi = new AuthenticationApi();
loginInfo = authApi.Login();
}
//else
// loginInfo.LoginAccounts.Add();
return(loginInfo);
}
private LoginAccount GetLoginInfo(DocuSignAuthHeader headerOptions)
{
var basePath = "https://demo.docusign.net/restapi";
var apiClient = new ApiClient(basePath);
Configuration.Default.ApiClient = apiClient;
var authHeader = JsonConvert.SerializeObject(headerOptions);
if (!Configuration.Default.DefaultHeader.ContainsKey("X-DocuSign-Authentication"))
{
Configuration.Default.AddDefaultHeader("X-DocuSign-Authentication", authHeader);
}
var authApi = new AuthenticationApi();
var loginInfoResult = authApi.Login();
var loginInfo = loginInfoResult.LoginAccounts.First();
return(loginInfo);
}
private string GetAccountID()
{
if (Utility.IsEventLogged)
{
Utility.LogAction("Get Account ID");
}
string authHeader = "{\"Username\":\"" + _email + "\", \"Password\":\"" + _password + "\", \"IntegratorKey\":\"" + _integratorKey + "\"}";
DocuSign.eSign.Client.Configuration.Default.AddDefaultHeader("X-DocuSign-Authentication", authHeader);
if (Utility.IsEventLogged)
{
Utility.LogAction("Auth Login");
}
AuthenticationApi authApi = new AuthenticationApi();
LoginInformation loginInfo = authApi.Login();
return(Utility.DocuSignAccountID = loginInfo.LoginAccounts[0].AccountId);
}
private static void DoLogin()
{
string Username = "******";
string Password = "******";
string IntegratorKey = "068a8288-e7be-466c-9103-31bb707a8cd0";
// set demo (aka test) environment (for production change to www.docusign.net/restapi)
string basePath = "https://demo.docusign.net/restapi";
// instantiate a new api client and set desired environment
ApiClient apiClient = new ApiClient(basePath);
// set client in global config so we don't have to pass it to each API object.
Configuration.Default.ApiClient = apiClient;
// create JSON formatted auth header containing Username, Password, and Integrator Key
string authHeader = "{\"Username\":\"" + Username + "\", \"Password\":\"" + Password + "\", \"IntegratorKey\":\"" + IntegratorKey + "\"}";
Configuration.Default.AddDefaultHeader("X-DocuSign-Authentication", authHeader);
// the authentication api uses the apiClient (and X-DocuSign-Authentication header) that are set in Configuration object
AuthenticationApi authApi = new AuthenticationApi();
LoginInformation loginInfo = authApi.Login();
Console.WriteLine("LoginInformation: {0}", loginInfo.ToJson());
}
private static Func <BaseRequestModel, string> AuthenticateFunc()
{
return(request =>
{
Configuration.Default.ApiClient = request.ESignAccount.IsTestApi.HasValue && request.ESignAccount.IsTestApi.Value
? new ApiClient(request.ESignAccount.ApiUrl)
: new ApiClient();
Configuration.Default.DefaultHeader.Clear();
Configuration.Default.AddDefaultHeader("X-DocuSign-Authentication", GetAuthHeader(request.ESignAccount));
var authApi = new AuthenticationApi();
var loginInfo = authApi.Login();
//For Production environment
/*
* As returned by login method, the baseUrl includes the API version and account id. Split the string to obtain the basePath,
* just the server name and api name. Eg, you will receive https://na1.docusign.net/restapi/v2/accounts/123123123.
* You want just https://na1.docusign.net/restapi
* Instantiate the SDK using the basePath. Eg ApiClient apiClient = new ApiClient(basePath);
*/
if (!request.ESignAccount.IsTestApi.HasValue || !request.ESignAccount.IsTestApi.Value)
{
var baseURL = loginInfo.LoginAccounts.FirstOrDefault() != null?loginInfo.LoginAccounts.FirstOrDefault().BaseUrl : null;
if (!string.IsNullOrEmpty(baseURL))
{
var sLookFor = "restapi";
baseURL = baseURL.Substring(0, baseURL.IndexOf(sLookFor) + sLookFor.Length);
Configuration.Default.ApiClient = new ApiClient(baseURL);
}
}
return loginInfo.LoginAccounts
.Where(x => x.IsDefault == true.ToString())
.Select(x => x.AccountId).FirstOrDefault() ?? loginInfo.LoginAccounts[0].AccountId;
});
}
//Authenticates the user against DocuSign
public string Login(LoginRequestModel user)
{
try
{
// Credential come from login form via the LoginRequestModel
string Username = user.Username; //[EMAIL]";
string Password = user.Password; //[PASSWORD]";
string integratorKey = GlobalVariables.integratorKey;
// instantiate api client with appropriate environment (for production change to www.docusign.net/restapi)
string basePath = "https://demo.docusign.net/restapi";
// instantiate a new api client
ApiClient apiClient = new ApiClient(basePath);
// set client in global config so we don't need to pass it to each API object
Configuration.Default.ApiClient = apiClient;
string authHeader = "{\"Username\":\"" + Username + "\", \"Password\":\"" + Password + "\", \"IntegratorKey\":\"" + integratorKey + "\"}";
Configuration.Default.AddDefaultHeader("X-DocuSign-Authentication", authHeader);
// we will retrieve this from the login() results
string accountId = null;
// the authentication api uses the apiClient (and X-DocuSign-Authentication header) that are set in Configuration object
AuthenticationApi authApi = new AuthenticationApi();
LoginInformation loginInfo = authApi.Login();
// user might be a member of multiple accounts
accountId = loginInfo.LoginAccounts[0].AccountId;
//GlobalVariables.LoggedInAccountId = accountId;
return(accountId);
}
catch (Exception e)
{
return("Error " + e.Message);
}
}
static void Main(string[] args)
{
// Enter your DocuSign credentials
string Username = "******";
string Password = "******";
string IntegratorKey = "[INTEGRATOR_KEY]";
// specify the document (file) we want signed
string SignTest1File = @"[PATH/TO/DOCUMENT/TEST.PDF]";
// Enter recipient (signer) name and email address
string recipientName = "[SIGNER_NAME]";
string recipientEmail = "[SIGNER_EMAIL]";
// instantiate api client with appropriate environment (for production change to www.docusign.net/restapi)
string basePath = "https://demo.docusign.net/restapi";
// instantiate a new api client
ApiClient apiClient = new ApiClient(basePath);
// set client in global config so we don't need to pass it to each API object
Configuration.Default.ApiClient = apiClient;
string authHeader = "{\"Username\":\"" + Username + "\", \"Password\":\"" + Password + "\", \"IntegratorKey\":\"" + IntegratorKey + "\"}";
Configuration.Default.AddDefaultHeader("X-DocuSign-Authentication", authHeader);
// we will retrieve this from the login() results
string accountId = null;
// the authentication api uses the apiClient (and X-DocuSign-Authentication header) that are set in Configuration object
AuthenticationApi authApi = new AuthenticationApi();
LoginInformation loginInfo = authApi.Login();
// user might be a member of multiple accounts
accountId = loginInfo.LoginAccounts[0].AccountId;
Console.WriteLine("LoginInformation: {0}", loginInfo.ToJson());
// Read a file from disk to use as a document
byte[] fileBytes = File.ReadAllBytes(SignTest1File);
EnvelopeDefinition envDef = new EnvelopeDefinition();
envDef.EmailSubject = "[DocuSign C# SDK] - Please sign this doc";
// Add a document to the envelope
Document doc = new Document();
doc.DocumentBase64 = System.Convert.ToBase64String(fileBytes);
doc.Name = "TestFile.pdf";
doc.DocumentId = "1";
envDef.Documents = new List <Document>();
envDef.Documents.Add(doc);
// Add a recipient to sign the documeent
Signer signer = new Signer();
signer.Name = recipientName;
signer.Email = recipientEmail;
signer.RecipientId = "1";
// Create a |SignHere| tab somewhere on the document for the recipient to sign
signer.Tabs = new Tabs();
signer.Tabs.SignHereTabs = new List <SignHere>();
SignHere signHere = new SignHere();
signHere.DocumentId = "1";
signHere.PageNumber = "1";
signHere.RecipientId = "1";
signHere.XPosition = "100";
signHere.YPosition = "150";
signer.Tabs.SignHereTabs.Add(signHere);
envDef.Recipients = new Recipients();
envDef.Recipients.Signers = new List <Signer>();
envDef.Recipients.Signers.Add(signer);
// set envelope status to "sent" to immediately send the signature request
envDef.Status = "sent";
// Use the EnvelopesApi to send the signature request!
EnvelopesApi envelopesApi = new EnvelopesApi();
EnvelopeSummary envelopeSummary = envelopesApi.CreateEnvelope(accountId, envDef);
// print the JSON response
Console.WriteLine("EnvelopeSummary:\n{0}", JsonConvert.SerializeObject(envelopeSummary));
Console.Read();
}
/// <summary>
/// UploadDocuSignEnvelopeToSharePoint - uploads a COMPLETED DocuSign envelope to a Sharepoint folder named as envelopeID
/// </summary>
/// <param name="accountID"></param>
/// <param name="envelopeID"></param>
static public void UploadDocuSignEnvelopeToSharePoint(string accountID, string envelopeID)
{
string userId = ConfigurationManager.AppSettings["UserId"];
string oauthBasePath = ConfigurationManager.AppSettings["OAuthBasePath"];
string integratorKey = ConfigurationManager.AppSettings["IntegratorKey"];
string privateKeyFilename = AppContext.BaseDirectory + "PrivateKey.txt";
string host = ConfigurationManager.AppSettings["Host"];
int expiresInHours = 1;
string siteUrl = ConfigurationManager.AppSettings["SiteUrl"];
string targetLibrary = ConfigurationManager.AppSettings["TargetLibrary"];
string userName = ConfigurationManager.AppSettings["UserName"];
string password = ConfigurationManager.AppSettings["Password"];
ApiClient apiClient = new ApiClient(host);
apiClient.ConfigureJwtAuthorizationFlow(integratorKey, userId, oauthBasePath, privateKeyFilename, expiresInHours);
/////////////////////////////////////////////////////////////////
// STEP 1: LOGIN API
/////////////////////////////////////////////////////////////////
AuthenticationApi authApi = new AuthenticationApi(apiClient.Configuration);
LoginInformation loginInfo = authApi.Login();
// find the default account for this user
foreach (LoginAccount loginAcct in loginInfo.LoginAccounts)
{
if (loginAcct.IsDefault == "true")
{
accountID = loginAcct.AccountId;
string[] separatingStrings = { "/v2" };
// Update ApiClient with the new base url from login call
apiClient = new ApiClient(loginAcct.BaseUrl.Split(separatingStrings, StringSplitOptions.RemoveEmptyEntries)[0]);
break;
}
}
/////////////////////////////////////////////////////////////////
// STEP 2: GET DOCUMENTS API
/////////////////////////////////////////////////////////////////
EnvelopesApi envelopesApi = new EnvelopesApi(apiClient.Configuration);
Envelope envInfo = envelopesApi.GetEnvelope(accountID, envelopeID);
if (envInfo.Status.ToLower().CompareTo("completed") == 0)
{
// upload all documents for accountID and envelopeID
MemoryStream docStream = GetAllDocuments(accountID, envelopeID);
Console.WriteLine("Uploading to SharePoint all documents for envelope {0}", envelopeID);
string fileName = envInfo.EnvelopeId + ".pdf";
SharePointOnlineHelper.UploadFileStreamToSharePoint(siteUrl, userName, password, targetLibrary, docStream, fileName, envelopeID, false);
// upload Certificate of Completion for accountID and envelopeID
Console.WriteLine("Uploading to SharePoint the Certificate Of Completion for envelope {0}", envelopeID);
MemoryStream cocStream = GetCertificateOfCompletion(accountID, envelopeID);
fileName = "COC_" + envInfo.EnvelopeId + ".pdf";
SharePointOnlineHelper.UploadFileStreamToSharePoint(siteUrl, userName, password, targetLibrary, cocStream, fileName, envelopeID, false);
}
else
{
Console.WriteLine("Download DocuSign documents can be performed only for COMPLETED envelopes.");
}
}
static string CreateDocuSignEnvelope()
{
string userId = ConfigurationManager.AppSettings["UserId"];
string oauthBasePath = ConfigurationManager.AppSettings["OAuthBasePath"];
string integratorKey = ConfigurationManager.AppSettings["IntegratorKey"];
string privateKeyFilename = AppContext.BaseDirectory + "PrivateKey.txt";
string host = ConfigurationManager.AppSettings["Host"];
string templateId = ConfigurationManager.AppSettings["TemplateID"];
int expiresInHours = 1;
//string accountId = string.Empty;
ApiClient apiClient = new ApiClient(host);
apiClient.ConfigureJwtAuthorizationFlow(integratorKey, userId, oauthBasePath, privateKeyFilename, expiresInHours);
/////////////////////////////////////////////////////////////////
// STEP 1: LOGIN API
/////////////////////////////////////////////////////////////////
AuthenticationApi authApi = new AuthenticationApi(apiClient.Configuration);
LoginInformation loginInfo = authApi.Login();
// find the default account for this user
foreach (LoginAccount loginAcct in loginInfo.LoginAccounts)
{
if (loginAcct.IsDefault == "true")
{
accountID = loginAcct.AccountId;
string[] separatingStrings = { "/v2" };
// Update ApiClient with the new base url from login call
apiClient = new ApiClient(loginAcct.BaseUrl.Split(separatingStrings, StringSplitOptions.RemoveEmptyEntries)[0]);
break;
}
}
/////////////////////////////////////////////////////////////////
// STEP 2: CREATE ENVELOPE API
/////////////////////////////////////////////////////////////////
EnvelopeDefinition envDef = new EnvelopeDefinition();
envDef.EmailSubject = "MS Build Demo - Please sign this doc";
// assign recipient to template role by setting name, email, and role name. Note that the
// template role name must match the placeholder role name saved in your account template.
TemplateRole tRole = new TemplateRole();
tRole.Email = ConfigurationManager.AppSettings["RecipientEmail"];
tRole.Name = ConfigurationManager.AppSettings["RecipientName"];
tRole.RoleName = "Signer";
List <TemplateRole> rolesList = new List <TemplateRole>()
{
tRole
};
// add the role to the envelope and assign valid templateId from your account
envDef.TemplateRoles = rolesList;
envDef.TemplateId = templateId;
// set envelope status to "sent" to immediately send the signature request
envDef.Status = "sent";
// |EnvelopesApi| contains methods related to creating and sending Envelopes (aka signature requests)
EnvelopesApi envelopesApi = new EnvelopesApi(apiClient.Configuration);
EnvelopeSummary envelopeSummary = envelopesApi.CreateEnvelope(accountID, envDef);
return(envelopeSummary.EnvelopeId);
}
//Method to embed a document signing in a new browser tab
public ViewUrl SignDocument(ref SignRequestModel signRequest)
{
try
{
string Username = signRequest.Username; //[email]";
string Password = signRequest.Password; //[password]";
string IntegratorKey = GlobalVariables.integratorKey; //[INTEGRATOR_KEY]";
// Enter recipient (signer) name and email address
string recipientName = signRequest.RecipientName; //[SIGNER_NAME]";
string recipientEmail = signRequest.RecipientEmail; //[SIGNER_EMAIL]";
// instantiate api client with appropriate environment (for production change to www.docusign.net/restapi)
string basePath = "https://demo.docusign.net/restapi";
// instantiate a new api client
ApiClient apiClient = new ApiClient(basePath);
// set client in global config so we don't need to pass it to each API object
Configuration.Default.ApiClient = apiClient;
string authHeader = "{\"Username\":\"" + Username + "\", \"Password\":\"" + Password + "\", \"IntegratorKey\":\"" + IntegratorKey + "\"}";
Configuration.Default.AddDefaultHeader("X-DocuSign-Authentication", authHeader);
// we will retrieve this from the login() results
string accountId = null;
// the authentication api uses the apiClient (and X-DocuSign-Authentication header) that are set in Configuration object
AuthenticationApi authApi = new AuthenticationApi();
LoginInformation loginInfo = authApi.Login();
// user might be a member of multiple accounts
accountId = loginInfo.LoginAccounts[0].AccountId;
//// Use the EnvelopesApi to create and send the signature request
EnvelopesApi envelopesApi = new EnvelopesApi();
//Giving the recipient the view.
RecipientViewRequest viewOptions = new RecipientViewRequest()
{
ReturnUrl = "https://www.docusign.com/devcenter",
ClientUserId = "1234", // must match clientUserId set in step #2!
AuthenticationMethod = "email",
UserName = recipientName,
Email = recipientEmail
};
// create the recipient view (aka signing URL)
ViewUrl recipientView = envelopesApi.CreateRecipientView(signRequest.AccountId, signRequest.EnvelopeId, viewOptions);
// print the JSON response
//Console.WriteLine("ViewUrl:\n{0}", JsonConvert.SerializeObject(recipientView));
// Start the embedded signing session!
return(recipientView);
}
catch (Exception e)
{
signRequest.Message = e.Message;
return(null);
}
}