public UnitOfWork(ApplicationDbContext context)
{
_context = context;
Attempts = new AttemptRepository(_context);
Exams = new ExamRepository(_context);
Images = new ImageRepository(_context);
NoteParameters = new NoteParameterRepository(_context);
Notifications = new NotificationRepository(_context);
Notes = new NoteRepository(_context);
Opinions = new OpinionRepository(_context);
Options = new OptionRepository(_context);
Passages = new PassageRepository(_context);
Questions = new QuestionRepository(_context);
Requirements = new RequirementRepository(_context);
Roles = new RoleRepository(_context);
RoleClaims = new RoleClaimRepository(_context);
Standards = new StandardRepository(_context);
Sittings = new SittingRepository(_context);
Topics = new TopicRepository(_context);
Users = new UserRepository(_context);
UserClaims = new UserClaimRepository(_context);
UserLogins = new UserLoginRepository(_context);
UserRoles = new UserRoleRepository(_context);
UserTokens = new UserTokenRepository(_context);
}
public UserUnitOfWork(AyudaContext context)
{
Context = context;
Users = new UserRepository(Context);
UserTokens = new UserTokenRepository(context);
UserLogins = new UserLoginRepository(context);
UserProfiles = new UserProfileRepository(context);
}
public TokensController(IdentityContext identityContext,
UserRepository userRepository,
UserTokenRepository userTokenRepository)
{
this._identityContext = identityContext;
this._userRepository = userRepository;
this._userTokenRepository = userTokenRepository;
}
public UserTokenRepositoryTest()
{
var options = new DbContextOptionsBuilder <FlyItContext>()
.UseInMemoryDatabase(databaseName: "FlyIt-UserToken")
.Options;
flyItContext = new FlyItContext(options);
tokenRepository = new UserTokenRepository(flyItContext);
}
public HttpResponseMessage GetEnvelopeXMLByCode(int envelopeCode)
{
HttpResponseMessage responseToClient = new HttpResponseMessage();
Byte[] info;
Guid envelopeId;
var doc = new XmlDocument();
try
{
System.Collections.Generic.IEnumerable <string> iHeader;
Request.Headers.TryGetValues("AuthToken", out iHeader);
string authToken = iHeader.ElementAt(0);
using (var dbContext = new eSignEntities())
{
UserTokenRepository tokenRepository = new UserTokenRepository(dbContext);
EnvelopeRepository envelopeRepository = new EnvelopeRepository(dbContext);
string userEmail = tokenRepository.GetUserEmailByToken(authToken);
Guid UserId = tokenRepository.GetUserProfileUserIDByID(tokenRepository.GetUserProfileIDByEmail(userEmail));
string eId = envelopeRepository.GetEnvelopeIdByDisplayCode(envelopeCode, UserId);
if (string.IsNullOrEmpty(eId))
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.NoContent;
responseMessage.StatusMessage = "NoContent";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["NoContent"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.NoContent, responseMessage, Configuration.Formatters.XmlFormatter);
return(responseToClient);
}
envelopeId = new Guid(eId);
Envelope newEnvelope = envelopeRepository.GetEntity(envelopeId);
if (newEnvelope == null)
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.NoContent;
responseMessage.StatusMessage = "NoContent";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["NoContent"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.OK, responseMessage);
return(responseToClient);
}
info = new UTF8Encoding(true).GetBytes(newEnvelope.EnvelopeContent.First().ContentXML);
string xml = Encoding.UTF8.GetString(info);
doc.LoadXml(xml);
responseToClient = Request.CreateResponse(HttpStatusCode.OK, doc, Configuration.Formatters.XmlFormatter);
return(responseToClient);
}
}
catch (Exception ex)
{
responseToClient = Request.CreateResponse((HttpStatusCode)422);
responseToClient.Content = new StringContent(ex.Message, Encoding.Unicode);
throw new HttpResponseException(responseToClient);
}
}
public HttpResponseMessage GetEnvelopeList()
{
var manageEnvelope = new List <EnvelopeGetenvelopeHistory>();
HttpResponseMessage responseToClient = new HttpResponseMessage();
try
{
System.Collections.Generic.IEnumerable <string> iHeader;
Request.Headers.TryGetValues("AuthToken", out iHeader);
string authToken = iHeader.ElementAt(0);
using (var dbContext = new eSignEntities())
{
UserTokenRepository tokenRepository = new UserTokenRepository(dbContext);
EnvelopeRepository envelopeRepository = new EnvelopeRepository(dbContext);
string userEmail = tokenRepository.GetUserEmailByToken(authToken);
Guid UserId = tokenRepository.GetUserProfileUserIDByID(tokenRepository.GetUserProfileIDByEmail(userEmail));
Envelopes = envelopeRepository.GetAll(UserId).OrderByDescending(r => r.CreatedDateTime).Where(r => r.DisplayCode != null && r.DisplayCode != 0 && r.IsEnvelopeComplete == true).ToList();
}
EnvelopeGetenvelopeHistory mngEnvlop = new EnvelopeGetenvelopeHistory();
foreach (var env in Envelopes)
{
mngEnvlop = new EnvelopeGetenvelopeHistory();
mngEnvlop.EnvelopeCode = env.DisplayCode;
mngEnvlop.Subject = env.Subject;
mngEnvlop.CurrentStatus = env.EnvelopeStatusDescription;
mngEnvlop.Sent = String.Format("{0:MM/dd/yyyy HH:mm tt}", env.CreatedDateTime);
if (env.StatusID != Constants.StatusCode.Envelope.Waiting_For_Signature)
{
mngEnvlop.Completed = String.Format("{0:MM/dd/yyyy HH:mm tt}", env.ModifiedDateTime);
}
manageEnvelope.Add(mngEnvlop);
}
if (manageEnvelope.Count == 0)
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.NoContent;
responseMessage.StatusMessage = "NoContent";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["NoContent"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.NoContent, responseMessage);
return(responseToClient);
}
else
{
responseToClient = Request.CreateResponse(HttpStatusCode.OK, manageEnvelope);
return(responseToClient);
}
}
catch (Exception ex)
{
responseToClient = Request.CreateResponse((HttpStatusCode)422);
responseToClient.Content = new StringContent(ex.Message, Encoding.Unicode);
throw new HttpResponseException(responseToClient);
}
}
public HttpResponseMessage AuthenticateUser(UserProfileToken objUser)
{
ResponseTokenWithEmailId respToken = new ResponseTokenWithEmailId();
try
{
UserToken userProfile = new UserToken();
userProfile.EmailId = objUser.EmailId;
var rpostServiceAPI = new RpostServiceAPI();
using (var dbcontext = new eSignEntities())
{
UserTokenRepository tokenRepository = new UserTokenRepository(dbcontext);
eSign.Notification.RpostService.AuthorizationResponse response = rpostServiceAPI.AuthenticateUser(objUser.EmailId, objUser.Password);
if (!string.IsNullOrEmpty(response.AuthorizationKey))
{
UserToken objToken = new UserToken();
objToken.ID = tokenRepository.GetUserProfileIDByEmail(objUser.EmailId);
objToken.EmailId = objUser.EmailId;
objToken.AuthToken = response.AuthorizationKey;
objToken.LastUpdated = DateTime.Now;
objToken.ExpiresIn = DateTime.Now.AddDays(Convert.ToDouble(ConfigurationManager.AppSettings["ExpiryDays"]));
bool result = tokenRepository.Save(objToken);
dbcontext.SaveChanges();
respToken.AuthMessage = Convert.ToString(ConfigurationManager.AppSettings["TokenSuccess"].ToString());
respToken.AuthToken = response.AuthorizationKey;
respToken.EmailId = objUser.EmailId;
HttpResponseMessage responseToClient = Request.CreateResponse(HttpStatusCode.OK, respToken);
return(responseToClient);
}
else
{
ResponseMessageWithEmailId responseMessage = new ResponseMessageWithEmailId();
responseMessage.StatusCode = HttpStatusCode.NotAcceptable;
responseMessage.StatusMessage = "NotAcceptable";
responseMessage.Message = Convert.ToString(System.Configuration.ConfigurationManager.AppSettings["InvalidUser"].ToString());
responseMessage.EmailId = objUser.EmailId;
HttpResponseMessage responseToClient = Request.CreateResponse(HttpStatusCode.NotAcceptable, responseMessage);
return(responseToClient);
}
}
}
catch (Exception ex)
{
HttpResponseMessage responseToClient = Request.CreateResponse((HttpStatusCode)422);
responseToClient.Content = new StringContent(ex.Message, Encoding.Unicode);
throw new HttpResponseException(responseToClient);
}
}
public AuthController(UserManager <User> userManager,
SignInManager <User> signInManager,
IOptions <JwtSecuritySettings> jwtSettings,
UserTokenRepository tokenRepository,
ILogger <AuthController> logger)
{
this.userManager = userManager;
this.passwordHasher = userManager.PasswordHasher;
this.jwtSettings = jwtSettings.Value;
this.logger = logger;
this.tokenRepository = tokenRepository;
}
public HttpResponseMessage GetDashboardData()
{
var userProfile = new UserProfile();
DashBoard dashBoard = new DashBoard();
HttpResponseMessage responseToClient = new HttpResponseMessage();
try
{
System.Collections.Generic.IEnumerable <string> iHeader;
Request.Headers.TryGetValues("AuthToken", out iHeader);
string authToken = iHeader.ElementAt(0);
using (var dbContext = new eSignEntities())
{
UserTokenRepository tokenRepository = new UserTokenRepository(dbContext);
string userEmail = tokenRepository.GetUserEmailByToken(authToken);
UserRepository objRepository = new UserRepository(dbContext);
userProfile = objRepository.GetUserProfile(tokenRepository.GetUserProfileUserIDByID(tokenRepository.GetUserProfileIDByEmail(userEmail)), userEmail, true);
if (userProfile == null)
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.NoContent;
responseMessage.StatusMessage = "NoContent";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["NoDataFound"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.NoContent, responseMessage);
return(responseToClient);
}
userId = userProfile.UserID;
dashBoard = Assignment.DashboardAssignment(dashBoard, userProfile);
dashBoard.ProfilePicLocation = PictureUrl(userProfile);
responseToClient = Request.CreateResponse(HttpStatusCode.OK, dashBoard);
return(responseToClient);
}
}
catch (Exception ex)
{
responseToClient = Request.CreateResponse((HttpStatusCode)422);
responseToClient.Content = new StringContent(ex.Message, Encoding.Unicode);
throw new HttpResponseException(responseToClient);
}
}
public bool Authorize(HttpRequestMessage Request)
{
try
{
System.Collections.Generic.IEnumerable <string> iHeader;
if (!Request.Headers.TryGetValues("AuthToken", out iHeader))
{
//ErrorMessage = "missing auth_token header";
return(false);
}
string authToken = iHeader.ElementAt(0);
if (authToken == string.Empty || authToken == null)
{
return(false);
}
using (var dbcontext = new eSignEntities())
{
UserTokenRepository tokenRepository = new UserTokenRepository(dbcontext);
tokenInformation = tokenRepository.IsUserAuthenticated(authToken);
if (tokenInformation == "User is authenticated")
{
return(true);
}
else
{
return(false);
}
}
}
catch (Exception ex)
{
var responseToClient = new HttpResponseMessage()
{
StatusCode = (HttpStatusCode)422, //Unprocessable Entity
ReasonPhrase = ex.Message
};
throw new HttpResponseException(responseToClient);
}
}
protected void Page_Load(object sender, EventArgs e)
{
Logout();
if (!IsPostBack)
{
string qs_loginToken = Request.QueryString["loginToken"];
if (!string.IsNullOrWhiteSpace(qs_loginToken) && !string.IsNullOrWhiteSpace(qs_loginToken))
{
UserToken userToken = UserTokenRepository.GetUserToken(qs_loginToken);
if (userToken != null)
{
Perform_login(userToken.User, userToken.Password, true, true);
}
else
{
ScriptManager.RegisterStartupScript(this, typeof(Page), "ShowErrorMessage", "ShowErrorMessage('" + 2 + "');", true);
}
}
}
}
public CustomUserStore(UserRepository userRepository, UserTokenRepository userTokenRepository)
{
_userRepository = userRepository;
_userTokenRepository = userTokenRepository;
}
public HttpResponseMessage GetEnvelopeHistoryByCode(int envelopeCode)
{
HttpResponseMessage responseToClient = new HttpResponseMessage();
EnvelopeGetEnvelopeHistoryByEnvelopeCode newEnvelope = new EnvelopeGetEnvelopeHistoryByEnvelopeCode();
string userName = string.Empty;
try
{
System.Collections.Generic.IEnumerable <string> iHeader;
Request.Headers.TryGetValues("AuthToken", out iHeader);
string authToken = iHeader.ElementAt(0);
using (var dbContext = new eSignEntities())
{
UserTokenRepository tokenRepository = new UserTokenRepository(dbContext);
EnvelopeRepository envelopeRepository = new EnvelopeRepository(dbContext);
string userEmail = tokenRepository.GetUserEmailByToken(authToken);
Guid UserId = tokenRepository.GetUserProfileUserIDByID(tokenRepository.GetUserProfileIDByEmail(userEmail));
userName = envelopeRepository.GetUserNameByAuthToken(authToken);
Envelopes = envelopeRepository.GetAll(UserId).OrderByDescending(r => r.CreatedDateTime).Where(r => r.DisplayCode != null && r.DisplayCode != 0 && r.IsEnvelopeComplete == true).ToList();
foreach (var env in Envelopes)
{
if (env.DisplayCode == envelopeCode)//envelope.EnvelopeCode)
{
newEnvelope.DocumentList = new List <string>();
newEnvelope.DocumentHistory = new List <DocumentStatus>();
var documentList = env.Documents.Select(m => m.DocumentName).ToList();
string recipients = string.Empty;
newEnvelope.EnvelopeCode = env.DisplayCode;
newEnvelope.Subject = env.Subject;
newEnvelope.CurrentStatus = env.EnvelopeStatusDescription;
newEnvelope.Sent = String.Format("{0:MM/dd/yyyy HH:mm tt}", env.CreatedDateTime);
if (env.StatusID != Constants.StatusCode.Envelope.Waiting_For_Signature)
{
newEnvelope.Completed = String.Format("{0:MM/dd/yyyy HH:mm tt}", env.ModifiedDateTime);
}
for (int i = 0; i < documentList.Count; i++)
{
newEnvelope.DocumentList.Add(documentList[i]);
}
newEnvelope.EnvelopeID = env.EnvelopeCodeDisplay;
newEnvelope.Sender = userName;
foreach (var recipient in env.Recipients.OrderByDescending(r => r.RecipientTypeDescription).ToList())
{
if (recipient.RecipientTypeID == Constants.RecipientType.Sender) // Sender
{
continue;
}
if (recipient.RecipientTypeID == Constants.RecipientType.CC) // CC
{
recipients += recipient.Name + "(CC), ";
}
else if (recipient.RecipientTypeID == Constants.RecipientType.Signer) // Signer
{
recipients += recipient.Name + ", ";
}
}
if (!string.IsNullOrEmpty(recipients))
{
recipients = recipients.Substring(0, recipients.Length - 2);
}
foreach (var recipient in env.Recipients.OrderBy(r => r.StatusDate))
{
DocumentStatus docHistory = new DocumentStatus();
if (recipient.RecipientTypeID == Constants.RecipientType.CC ||
(recipient.StatusID == null || recipient.StatusID == Guid.Empty))
{
continue;
}
if (recipient.RecipientTypeID == Constants.RecipientType.Signer)
{
docHistory.StatusDate = String.Format("{0:MM/dd/yyyy HH:mm tt}", recipient.StatusDate) + " " + GetTimeZone.GetTimeZoneAbbreviation(TimeZone.CurrentTimeZone.StandardName);
if (recipient.StatusID == Constants.StatusCode.Signer.Delegated)
{
newEnvelope.DelegatedTo = recipient.DelegatedTo;
}
else
{
docHistory.SignerStatusDescription = recipient.SignerStatusDescription;
docHistory.Recipient = recipient.Name;
docHistory.RecipientEmailAddress = recipient.EmailAddress;
if (recipient.StatusID == Constants.StatusCode.Signer.Pending)
{
docHistory.IPAddress = "-.-.-.-";
}
else
{
docHistory.IPAddress = recipient.SignerIPAddress;
}
}
}
newEnvelope.DocumentHistory.Add(docHistory);
}
if (env.StatusID == Constants.StatusCode.Envelope.Completed)
{
var recipient = env.Recipients.Where(r => r.StatusID == Constants.StatusCode.Signer.Signed).OrderByDescending(r => r.StatusDate).FirstOrDefault();
newEnvelope.CompletedStatusDate = String.Format("{0:MM/dd/yyyy HH:mm tt}", recipient.StatusDate) + " " + GetTimeZone.GetTimeZoneAbbreviation(TimeZone.CurrentTimeZone.StandardName);
newEnvelope.EnvelopeStatusDescription = env.EnvelopeStatusDescription;
}
if (env.StatusID == Constants.StatusCode.Envelope.Terminated)
{
var recipient = env.Recipients.Where(r => r.StatusID == Constants.StatusCode.Signer.Rejected).OrderByDescending(r => r.StatusDate).First();
newEnvelope.CompletedStatusDate = String.Format("{0:MM/dd/yyyy HH:mm tt}", recipient.StatusDate) + " " + GetTimeZone.GetTimeZoneAbbreviation(TimeZone.CurrentTimeZone.StandardName);
newEnvelope.EnvelopeStatusDescription = env.EnvelopeStatusDescription;
}
}
}
}
if (newEnvelope.EnvelopeCode == 0)
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.NoContent;
responseMessage.StatusMessage = "NoContent";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["NoContent"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.NoContent, responseMessage);
return(responseToClient);
}
else
{
responseToClient = Request.CreateResponse(HttpStatusCode.OK, newEnvelope);
return(responseToClient);
}
}
catch (Exception ex)
{
responseToClient = Request.CreateResponse((HttpStatusCode)422);
responseToClient.Content = new StringContent(ex.Message, Encoding.Unicode);
throw new HttpResponseException(responseToClient);
}
}
public HttpResponseMessage ResendEmail(int envelopeCode)
{
HttpResponseMessage responseToClient = new HttpResponseMessage();
//eSign.Web.Controllers.DocumentPackageController doc = new Web.Controllers.DocumentPackageController();
EnvelopeHelperMain objEnvelope = new EnvelopeHelperMain();
Guid envelopeId;
try
{
System.Collections.Generic.IEnumerable <string> iHeader;
Request.Headers.TryGetValues("AuthToken", out iHeader);
string authToken = iHeader.ElementAt(0);
using (var dbContext = new eSignEntities())
{
//var helper = new eSign.Web.Helpers.EnvelopeHelper();
EnvelopeRepository envelopeRepository = new EnvelopeRepository(dbContext);
UserTokenRepository tokenRepository = new UserTokenRepository(dbContext);
string userEmail = tokenRepository.GetUserEmailByToken(authToken);
Guid UserId = tokenRepository.GetUserProfileUserIDByID(tokenRepository.GetUserProfileIDByEmail(userEmail));
string eId = envelopeRepository.GetEnvelopeIdByDisplayCode(envelopeCode, UserId);
if (string.IsNullOrEmpty(eId))
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.NoContent;
responseMessage.StatusMessage = "NoContent";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["NoContent"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.NoContent, responseMessage);
return(responseToClient);
}
envelopeId = new Guid(eId);
Envelope envelopeObject = envelopeRepository.GetEntity(envelopeId);
if (envelopeObject == null)
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.NoContent;
responseMessage.StatusMessage = "NoContent";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["NoContent"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.OK, responseMessage);
return(responseToClient);
}
if (envelopeObject.StatusID == Constants.StatusCode.Envelope.Incomplete_and_Expired)
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.BadRequest;
responseMessage.StatusMessage = "BadRequest";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["IncompleteAndExpired"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.BadRequest, responseMessage);
return(responseToClient);
}
else if (envelopeObject.StatusID == Constants.StatusCode.Envelope.Terminated)
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.BadRequest;
responseMessage.StatusMessage = "BadRequest";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["Terminated"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.BadRequest, responseMessage);
return(responseToClient);
}
var JsonResult = objEnvelope.SendmailReminderAPI(Convert.ToString(envelopeId), tokenRepository.GetUserEmailByToken(authToken));
if (JsonResult == "All signers has signed the document")
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.BadRequest;
responseMessage.StatusMessage = "BadRequest";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["AllSigned"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.BadRequest, responseMessage);
return(responseToClient);
}
else if (JsonResult == "The email has been resent")
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.OK;
responseMessage.StatusMessage = "OK";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["MailResend"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.OK, responseMessage);
return(responseToClient);
}
else
{
responseToClient = Request.CreateResponse((HttpStatusCode)422);
responseToClient.Content = new StringContent(JsonResult, Encoding.Unicode);
throw new HttpResponseException(responseToClient);
}
}
}
catch (Exception ex)
{
responseToClient = Request.CreateResponse((HttpStatusCode)422);
responseToClient.Content = new StringContent(ex.Message, Encoding.Unicode);
throw new HttpResponseException(responseToClient);
}
}
public HttpResponseMessage GetFinalSignedPDFDocumentHeader(int envelopeCode)
{
HttpResponseMessage responseToClient = new HttpResponseMessage();
var base64String = string.Empty;
byte[] binaryData = new Byte[102222];
//eSign.Web.Controllers.DocumentPackageController doc = new Web.Controllers.DocumentPackageController();
EnvelopeHelperMain objEnvelope = new EnvelopeHelperMain();
Guid envelopeId;
string finalDocumentName = string.Empty;
try
{
System.Collections.Generic.IEnumerable <string> iHeader;
Request.Headers.TryGetValues("AuthToken", out iHeader);
string authToken = iHeader.ElementAt(0);
using (var objectcontext = new eSignEntities())
{
//var helper = new eSign.Web.Helpers.EnvelopeHelper();
UserTokenRepository tokenRepository = new UserTokenRepository(objectcontext);
EnvelopeRepository envelopeRepository = new EnvelopeRepository(objectcontext);
string userEmail = tokenRepository.GetUserEmailByToken(authToken);
Guid UserId = tokenRepository.GetUserProfileUserIDByID(tokenRepository.GetUserProfileIDByEmail(userEmail));
string eId = envelopeRepository.GetEnvelopeIdByDisplayCode(envelopeCode, UserId);
finalDocumentName = envelopeRepository.GetFinalDocumentName(new Guid(eId));
if (string.IsNullOrEmpty(eId))
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.NoContent;
responseMessage.StatusMessage = "NoContent";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["NoContent"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.OK, responseMessage);
return(responseToClient);
}
envelopeId = new Guid(eId);
Envelope envelopeObject = envelopeRepository.GetEntity(envelopeId);
if (envelopeObject == null)
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.NoContent;
responseMessage.StatusMessage = "NoContent";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["NoContent"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.OK, responseMessage);
return(responseToClient);
}
if (envelopeObject.StatusID == Constants.StatusCode.Envelope.Waiting_For_Signature)
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.BadRequest;
responseMessage.StatusMessage = "BadRequest";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["PartialComplete"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.OK, responseMessage);
return(responseToClient);
}
else if (envelopeObject.StatusID == Constants.StatusCode.Envelope.Incomplete_and_Expired)
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.BadRequest;
responseMessage.StatusMessage = "BadRequest";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["IncompleteAndExpired"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.OK, responseMessage);
return(responseToClient);
}
else if (envelopeObject.StatusID == Constants.StatusCode.Envelope.Terminated)
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.BadRequest;
responseMessage.StatusMessage = "BadRequest";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["Terminated"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.OK, responseMessage);
return(responseToClient);
}
string permanentPDFFilePath = ConfigurationManager.AppSettings["PermanentPDFPathStart"].ToString() + envelopeId.ToString() + ConfigurationManager.AppSettings["PermanentPDFPathEnd"].ToString();
string finalPdfFilePath = ConfigurationManager.AppSettings["PDFPathStart"].ToString() + envelopeId.ToString() + ConfigurationManager.AppSettings["PDFPathEnd"].ToString();
if (System.IO.File.Exists(permanentPDFFilePath))
{
System.IO.FileStream inFile;
inFile = new System.IO.FileStream(permanentPDFFilePath, System.IO.FileMode.Open, System.IO.FileAccess.Read);
binaryData = new Byte[inFile.Length];
long bytesRead = inFile.Read(binaryData, 0, (int)inFile.Length);
base64String = Convert.ToBase64String(binaryData, 0, (int)bytesRead);
inFile.Close();
}
else if (System.IO.File.Exists(finalPdfFilePath))
{
System.IO.FileStream inFile;
inFile = new System.IO.FileStream(finalPdfFilePath, System.IO.FileMode.Open, System.IO.FileAccess.Read);
binaryData = new Byte[inFile.Length];
long bytesRead = inFile.Read(binaryData, 0, (int)inFile.Length);
base64String = Convert.ToBase64String(binaryData, 0, (int)bytesRead);
inFile.Close();
}
else
{
var result = objEnvelope.DownloadPDFApi(envelopeObject);
System.IO.FileStream inFile;
inFile = new System.IO.FileStream(result, System.IO.FileMode.Open, System.IO.FileAccess.Read);
binaryData = new Byte[inFile.Length];
long bytesRead = inFile.Read(binaryData, 0, (int)inFile.Length);
base64String = Convert.ToBase64String(binaryData, 0, (int)bytesRead);
inFile.Close();
}
}
ResponseMessagePDF responseMessagePDF = new ResponseMessagePDF();
responseMessagePDF.StatusCode = HttpStatusCode.OK;
responseMessagePDF.StatusMessage = "OK";
responseMessagePDF.FileName = finalDocumentName + ".pdf";
responseMessagePDF.Message = "Following is the binary data of pdf.";
responseMessagePDF.PdfInBinary = binaryData;
responseToClient = Request.CreateResponse(HttpStatusCode.OK, responseMessagePDF);
return(responseToClient);
}
catch (Exception ex)
{
responseToClient = Request.CreateResponse((HttpStatusCode)422);
responseToClient.Content = new StringContent(ex.Message, Encoding.Unicode);
throw new HttpResponseException(responseToClient);
}
}
public HttpResponseMessage UploadSkydriveDocument(UploadSkydriveDocument documentSkyDrive)
{
HttpResponseMessage responseToClient = new HttpResponseMessage();
ResponseMessageDocument responseMessage = new ResponseMessageDocument();
bool fileDuplicateFlag = false;
try
{
System.Collections.Generic.IEnumerable <string> iHeader;
Request.Headers.TryGetValues("AuthToken", out iHeader);
string authToken = iHeader.ElementAt(0);
string tempDirectory = ConfigurationManager.AppSettings["TempDirectory"].ToString() + documentSkyDrive.EnvelopeId;
using (var dbContext = new eSignEntities())
{
EnvelopeRepository envelopeRepository = new EnvelopeRepository(dbContext);
bool isEnvelopePrepare = envelopeRepository.IsEnvelopePrepare(new Guid(documentSkyDrive.EnvelopeId));
if (!Directory.Exists(tempDirectory))
{
responseMessage.StatusCode = HttpStatusCode.BadRequest;
responseMessage.StatusMessage = "BadRequest";
responseMessage.Message = ConfigurationManager.AppSettings["EnvelopeIdMissing"].ToString();
responseMessage.EnvelopeId = documentSkyDrive.EnvelopeId;
responseToClient = Request.CreateResponse(HttpStatusCode.BadRequest, responseMessage);
return(responseToClient);
}
else if (isEnvelopePrepare == true)
{
responseMessage.StatusCode = HttpStatusCode.BadRequest;
responseMessage.StatusMessage = "BadRequest";
responseMessage.Message = ConfigurationManager.AppSettings["EnvelopePrepared"].ToString();
responseMessage.EnvelopeId = documentSkyDrive.EnvelopeId;
responseToClient = Request.CreateResponse(HttpStatusCode.BadRequest, responseMessage);
return(responseToClient);
}
else
{
UserTokenRepository userTokenRepository = new UserTokenRepository(dbContext);
string userEmail = userTokenRepository.GetUserEmailByToken(authToken);
Guid UserId = userTokenRepository.GetUserProfileUserIDByID(userTokenRepository.GetUserProfileIDByEmail(userEmail));
bool isEnvelopeExists = envelopeRepository.IsUserEnvelopeExists(UserId, new Guid(documentSkyDrive.EnvelopeId));
if (!isEnvelopeExists)
{
responseMessage.StatusCode = HttpStatusCode.NoContent;
responseMessage.StatusMessage = "NoContent";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["NoContent"].ToString());
responseMessage.EnvelopeId = documentSkyDrive.EnvelopeId;
responseToClient = Request.CreateResponse(HttpStatusCode.NoContent, responseMessage, Configuration.Formatters.XmlFormatter);
return(responseToClient);
}
string documentUploadPath = Path.Combine(tempDirectory, ConfigurationManager.AppSettings["UploadedDocuments"].ToString());
string docFinalPath = Path.Combine(documentUploadPath, documentSkyDrive.FileName);
if (!Directory.Exists(documentUploadPath))
{
Directory.CreateDirectory(documentUploadPath);
}
string[] listOfFiles = Directory.GetFiles(documentUploadPath);
foreach (var file in listOfFiles)
{
if (file.Contains(documentSkyDrive.FileName))
{
fileDuplicateFlag = true;
break;
}
}
if (fileDuplicateFlag)
{
responseMessage.StatusCode = HttpStatusCode.Ambiguous;
responseMessage.StatusMessage = "Ambiguous";
responseMessage.Message = ConfigurationManager.AppSettings["FileDuplicate"].ToString();
responseMessage.EnvelopeId = documentSkyDrive.EnvelopeId;
responseToClient = Request.CreateResponse(HttpStatusCode.Ambiguous, responseMessage);
return(responseToClient);
}
//string[] validFileTypes = { "docx", "pdf", "doc", "xls", "xlsx", "ppt", "pptx", "DOCX", "PDF", "DOC", "XLS", "XLSX", "PPT", "PPTX" };
//string ext = Path.GetExtension(documentSkyDrive.FileName);
//bool isValidType = false;
//for (int j = 0; j < validFileTypes.Length; j++)
//{
// if (ext == "." + validFileTypes[j])
// {
// isValidType = true;
// break;
// }
//}
//if (!isValidType)
//{
// responseMessage.StatusCode = HttpStatusCode.NotAcceptable;
// responseMessage.StatusMessage = "NotAcceptable";
// responseMessage.Message = ConfigurationManager.AppSettings["InvalidFileExtension"].ToString();
// responseMessage.EnvelopeId = documentSkyDrive.EnvelopeId;
// responseToClient = Request.CreateResponse(HttpStatusCode.NotAcceptable, responseMessage);
// return responseToClient;
//}
try
{
using (WebClient webClient = new WebClient())
{
webClient.DownloadFile(new Uri(documentSkyDrive.DownloadUrl), docFinalPath);
}
}
catch (WebException ex)
{
responseMessage.StatusCode = HttpStatusCode.BadRequest;
responseMessage.StatusMessage = "BadRequest";
responseMessage.Message = ConfigurationManager.AppSettings["InvalidDownloadUri"].ToString();
responseMessage.EnvelopeId = documentSkyDrive.EnvelopeId;
responseToClient = Request.CreateResponse(HttpStatusCode.BadRequest, responseMessage);
return(responseToClient);
}
Guid documentId = Guid.NewGuid();
DocumentRepository documentRepository = new DocumentRepository(dbContext);
UnitOfWork unitOfWork = new UnitOfWork(dbContext);
Documents doc = new Documents();
doc.ID = documentId;
doc.EnvelopeID = new Guid(documentSkyDrive.EnvelopeId);
doc.DocumentName = documentSkyDrive.FileName;
doc.UploadedDateTime = DateTime.Now;
int docCount = Directory.GetFiles(documentUploadPath).Length;
doc.Order = (short)(docCount);
documentRepository.Save(doc);
unitOfWork.SaveChanges();
responseMessage.StatusCode = HttpStatusCode.OK;
responseMessage.StatusMessage = "OK";
responseMessage.Message = ConfigurationManager.AppSettings["SuccessDocumentUpload"].ToString();
responseMessage.EnvelopeId = documentSkyDrive.EnvelopeId;
responseMessage.DocumentId = Convert.ToString(documentId);
responseToClient = Request.CreateResponse(HttpStatusCode.OK, responseMessage);
return(responseToClient);
}
}
}
catch (Exception e)
{
responseToClient = Request.CreateResponse((HttpStatusCode)422);
responseToClient.Content = new StringContent(e.Message, Encoding.Unicode);
throw new HttpResponseException(responseToClient);
}
}
public HttpResponseMessage DeleteDocument(string envelopeCode, string id)
{
string documentCode = id;
HttpResponseMessage responseToClient = new HttpResponseMessage();
ResponseMessageDocument responseMessage = new ResponseMessageDocument();
string documentName = string.Empty;
try
{
System.Collections.Generic.IEnumerable <string> iHeader;
Request.Headers.TryGetValues("AuthToken", out iHeader);
string authToken = iHeader.ElementAt(0);
string tempDirectory = ConfigurationManager.AppSettings["TempDirectory"].ToString();
string documentUploadPath = Path.Combine(tempDirectory, envelopeCode, ConfigurationManager.AppSettings["UploadedDocuments"].ToString());
using (var dbContext = new eSignEntities())
{
EnvelopeHelperMain envelopeHelperMain = new EnvelopeHelperMain();
var envelopeRepository = new EnvelopeRepository(dbContext);
if (!Directory.Exists(Path.Combine(tempDirectory, envelopeCode)))
{
responseMessage.StatusCode = HttpStatusCode.BadRequest;
responseMessage.StatusMessage = "BadRequest";
responseMessage.Message = ConfigurationManager.AppSettings["EnvelopeIdMissing"].ToString();
responseMessage.EnvelopeId = envelopeCode;
responseToClient = Request.CreateResponse(HttpStatusCode.BadRequest, responseMessage);
return(responseToClient);
}
bool isEnvelopePrepare = envelopeRepository.IsEnvelopePrepare(new Guid(envelopeCode));
if (isEnvelopePrepare == true)
{
responseMessage.StatusCode = HttpStatusCode.BadRequest;
responseMessage.StatusMessage = "BadRequest";
responseMessage.Message = ConfigurationManager.AppSettings["EnvelopePrepared"].ToString();
responseMessage.EnvelopeId = envelopeCode;
responseToClient = Request.CreateResponse(HttpStatusCode.BadRequest, responseMessage);
return(responseToClient);
}
DocumentRepository documentRepository = new DocumentRepository(dbContext);
UnitOfWork unitOfWork = new UnitOfWork(dbContext);
DocumentContentsRepository documentContentsRepository = new DocumentContentsRepository(dbContext);
Documents doc = documentRepository.GetEntity(new Guid(documentCode));
string documentPath = string.Empty;
if (doc != null)
{
documentName = doc.DocumentName;
documentPath = Path.Combine(documentUploadPath, documentName);
}
if (doc == null)
{
responseMessage.StatusCode = HttpStatusCode.BadRequest;
responseMessage.StatusMessage = "BadRequest";
responseMessage.Message = ConfigurationManager.AppSettings["DocumentIdMissing"].ToString();
responseMessage.EnvelopeId = envelopeCode;
responseToClient = Request.CreateResponse(HttpStatusCode.BadRequest, responseMessage);
return(responseToClient);
}
else
{
UserTokenRepository userTokenRepository = new UserTokenRepository(dbContext);
string userEmail = userTokenRepository.GetUserEmailByToken(authToken);
Guid UserId = userTokenRepository.GetUserProfileUserIDByID(userTokenRepository.GetUserProfileIDByEmail(userEmail));
bool isEnvelopeExists = envelopeRepository.IsUserEnvelopeExists(UserId, new Guid(envelopeCode));
if (!isEnvelopeExists)
{
responseMessage.StatusCode = HttpStatusCode.NoContent;
responseMessage.StatusMessage = "NoContent";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["NoContent"].ToString());
responseMessage.EnvelopeId = envelopeCode;
responseToClient = Request.CreateResponse(HttpStatusCode.NoContent, responseMessage, Configuration.Formatters.XmlFormatter);
return(responseToClient);
}
Envelope envelope = envelopeRepository.GetEntity(new Guid(envelopeCode));
envelopeHelperMain.SetApiCallFlag();
envelopeHelperMain.DeleteFile(envelope.Documents.Where(d => d.ID == new Guid(documentCode)).FirstOrDefault().DocumentName, Convert.ToString(envelope.ID), envelope.Documents.Count, envelope);
bool documentContentDelete = documentContentsRepository.Delete(doc);
bool documentDelete = documentRepository.Delete(new Guid(documentCode));
unitOfWork.SaveChanges();
if (documentDelete == true)
{
responseMessage.StatusCode = HttpStatusCode.OK;
responseMessage.StatusMessage = "OK";
responseMessage.Message = ConfigurationManager.AppSettings["DocumentDeleted"].ToString();
responseMessage.EnvelopeId = envelopeCode;
responseToClient = Request.CreateResponse(HttpStatusCode.OK, responseMessage);
return(responseToClient);
}
else
{
responseMessage.StatusCode = HttpStatusCode.OK;
responseMessage.StatusMessage = "OK";
responseMessage.Message = ConfigurationManager.AppSettings["DocumentDeleted"].ToString();
responseMessage.EnvelopeId = envelopeCode;
responseToClient = Request.CreateResponse(HttpStatusCode.OK, responseMessage);
return(responseToClient);
}
}
}
}
catch (Exception ex)
{
responseToClient = Request.CreateResponse((HttpStatusCode)422);
responseToClient.Content = new StringContent(ex.Message, Encoding.Unicode);
throw new HttpResponseException(responseToClient);
}
}
public UnitOfWorkIFXGame(IFXGameContext _context)
{
this.context = _context;
UserInfo = new UserInfoRepository(context);
UserToken = new UserTokenRepository(context);
}
public HttpResponseMessage SendEnvelope(TemplateSend template)
{
HttpResponseMessage responseToClient = new HttpResponseMessage();
try
{
int displayCode = 0;
bool flagRole = true;
System.Collections.Generic.IEnumerable<string> iHeader;
Request.Headers.TryGetValues("AuthToken", out iHeader);
string authToken = iHeader.ElementAt(0);
Envelope envelope = new Envelope();
Dictionary<string, string> roleDic = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
EnvelopeHelperMain objEnvelope = new EnvelopeHelperMain();
EntityCollection<Recipients> recipients = new EntityCollection<Recipients>();
Recipients recipint = new Recipients();
using (var dbContext = new eSignEntities())
{
List<Roles> roleList = new List<Roles>();
UserTokenRepository tokenRepository = new UserTokenRepository(dbContext);
EnvelopeRepository envelopeRepository = new EnvelopeRepository(dbContext);
string userEmail = tokenRepository.GetUserEmailByToken(authToken);
Guid UserId = tokenRepository.GetUserProfileUserIDByID(tokenRepository.GetUserProfileIDByEmail(userEmail));
envelope = envelopeRepository.GetTemplateDetails(template.TemplateCode, UserId);
if (envelope == null)
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.NoContent;
responseMessage.StatusMessage = "NoContent";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["NoContent"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.NoContent, responseMessage);
return responseToClient;
}
envelope.Message = template.MailBody;
envelope.Subject = template.MailSubject;
roleList = envelopeRepository.GetRoles(envelope.ID);
envelope.IsEnvelopeComplete = true;
envelope.IsEnvelopePrepare = true;
if (template.Recipients.Count != roleList.Count)
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.Forbidden;
responseMessage.StatusMessage = "Forbidden";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["RolesCount"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.Forbidden, responseMessage);
return responseToClient;
}
foreach (var recip in template.Recipients)
{
flagRole = EnvelopeHelper.IsEmailValid(recip.EmailAddress);
if (!flagRole)
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.Forbidden;
responseMessage.StatusMessage = "Forbidden";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["Email"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.Forbidden, responseMessage);
return responseToClient;
}
foreach (var role in roleList)
{
if (role.Name.ToLower() == recip.Role.ToLower())
{
recipint.EmailAddress = recip.EmailAddress;
recipint.Name = recip.Role;
recipint.Order = role.Order;
recipint.RecipientTypeID = role.RecipientTypeID;
roleDic.Add(recipint.Name, recipint.EmailAddress);
}
}
}
foreach (var role in roleList)
{
if (!roleDic.ContainsKey(role.Name))
flagRole = false;
}
if (!flagRole)
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.Forbidden;
responseMessage.StatusMessage = "Forbidden";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["RolesCount"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.Forbidden, responseMessage);
return responseToClient;
}
string Password = string.Empty;
if (envelope.PasswordReqdtoSign)
{
Password = ModelHelper.Decrypt(envelope.PasswordtoSign, envelope.PasswordKey, (int)envelope.PasswordKeySize);
envelope.PasswordtoSign = Password;
}
else
envelope.PasswordtoSign = null;
if (envelope.PasswordReqdtoOpen)
{
Password = ModelHelper.Decrypt(envelope.PasswordtoOpen, envelope.PasswordKey, (int)envelope.PasswordKeySize);
envelope.PasswordtoOpen = Password;
}
else
envelope.PasswordtoOpen = null;
roleDic.Add("Sender", userEmail);
objEnvelope.SetApiCallFlag();
bool status = objEnvelope.UpdatedEnvelope(envelope, template.TemplateCode, roleDic, userEmail, out displayCode);
if (status == false)
{
ResponseMessage responseMessageFail = new ResponseMessage();
responseMessageFail.StatusCode = HttpStatusCode.Ambiguous;
responseMessageFail.StatusMessage = "Ambiguous";
responseMessageFail.Message = Convert.ToString(ConfigurationManager.AppSettings["EnvelopeFail"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.OK, responseMessageFail);
return responseToClient;
}
}
ResponseMessageWithEnvID responseMessageSuccess = new ResponseMessageWithEnvID();
responseMessageSuccess.StatusCode = HttpStatusCode.OK;
responseMessageSuccess.StatusMessage = "OK";
responseMessageSuccess.EnvId = displayCode;
responseMessageSuccess.Message = Convert.ToString(ConfigurationManager.AppSettings["EnvelopeSucess"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.OK, responseMessageSuccess);
return responseToClient;
}
catch (Exception ex)
{
responseToClient = Request.CreateResponse((HttpStatusCode)422);
responseToClient.Content = new StringContent(Convert.ToString(ConfigurationManager.AppSettings["EnvelopeFail"].ToString()), Encoding.Unicode);
throw new HttpResponseException(responseToClient);
}
}
