public IActionResult ActivityHistory(int id)
{
using (var DataContext = new DocumentEntities())
{
var db = (from x in DataContext.ActivityHistories//.Where(x => x.DocumentID == id);
where x.DocumentID == id
select new
{
Status = x.DocumentStatu.Name,
InsertDate = x.InsertDate,
UserID = x.UserID
}).ToList();
var result = from x in db
select new ViewModels.ActivityHistoryViewModel
{
Status = x.Status,
InsertDate = x.InsertDate.ToString("g"),
UserName = username,
UserID = x.UserID
};
return(Json(result));
}
}
private bool HandleUpload(Stream fileStream, string name, int size, string type)
{
bool handled = false;
try
{
byte[] documentBytes = new byte[fileStream.Length];
fileStream.Read(documentBytes, 0, documentBytes.Length);
Document databaseDocument = new Document
{
CreatedOn = DateTime.Now,
FileContent = documentBytes,
IsDeleted = false,
Name = name,
Size = size,
Type = type
};
using (DocumentEntities databaseContext = new DocumentEntities())
{
databaseContext.Documents.Add(databaseDocument);
handled = (databaseContext.SaveChanges() > 0);
}
}
catch (Exception ex)
{
// Oops, something went wrong, handle the exception
Console.WriteLine(ex);
}
return(handled);
}
public static void RecordActivity(DocumentActivityOptions activity, int documentID, int userid)
{
var db = new DocumentEntities();
var newActivity = new ActivityHistory()
{
UserID = userid,
DocumentID = documentID,
InsertDate = DateTime.Now
};
switch (activity)
{
case DocumentActivityOptions.Created:
newActivity.StatusID = db.DocumentStatus.First(x => x.Code == DocumentActivityOptions.Created.ToString().ToLower()).Id;
break;
case DocumentActivityOptions.Viewed:
newActivity.StatusID = db.DocumentStatus.First(x => x.Code == DocumentActivityOptions.Viewed.ToString().ToLower()).Id;
break;
case DocumentActivityOptions.Signed:
newActivity.StatusID = db.DocumentStatus.First(x => x.Code == DocumentActivityOptions.Signed.ToString().ToLower()).Id;
break;
}
db.ActivityHistories.Add(newActivity);
db.SaveChanges();
}
public async Task <IHttpActionResult> Upload(int id)
{
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
return(BadRequest("Unsupported media type"));
}
try
{
var provider = new MultipartFormDataStreamProvider(HttpContext.Current.Server.MapPath("~/uploads/"));
var content = new StreamContent(HttpContext.Current.Request.GetBufferlessInputStream(true));
foreach (var header in Request.Content.Headers)
{
content.Headers.TryAddWithoutValidation(header.Key, header.Value);
}
await content.ReadAsMultipartAsync(provider);
using (var context = new DocumentEntities())
{
foreach (var file in provider.FileData)
{
using (var ts = new TransactionScope())
{
var documentMeta = new DocumentMeta
{
CollectionId = id,
FileName = file.Headers.ContentDisposition.Name.Trim(new char[] { '"' }).Replace("&", "and"),
UploadTime = DateTime.Now
};
context.DocumentMeta.Add(documentMeta);
context.SaveChanges();
var documentContent = new DocumentContent
{
Id = documentMeta.Id,
RowGuid = Guid.NewGuid(),
Data = new Byte[0]
};
context.DocumentContent.Add(documentContent);
context.SaveChanges();
using (var stream = File.OpenRead(file.LocalFileName))
{
DocumentContentHelper.AddContentData(documentContent.Id, context, stream);
}
ts.Complete();
}
}
}
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.GetBaseException().Message));
}
}
public async Task <IHttpActionResult> GetCollections()
{
using (var context = new DocumentEntities())
{
var list = await context.DocumentCollection.Where(c => c.DeleteTime == null).ToListAsync();
return(Ok(list));
}
}
public async Task <IHttpActionResult> Create([FromBody] DocumentCollection collection)
{
using (var context = new DocumentEntities())
{
context.DocumentCollection.Add(collection);
await context.SaveChangesAsync();
return(Ok(collection));
}
}
public IActionResult Index()
{
using (DocumentEntities DataContext = new DocumentEntities())
{
ViewBag.Count = DataContext.Documents.Count();
if (!DataContext.UserSignatures.Any(x => x.UserName == "mellison"))
{
return(RedirectToAction("Index", "Signature", null));
}
return(View());
}
}
// GET: /<controller>/
public IActionResult Index()
{
using (var DataContext = new DocumentEntities())
{
var vm = (from x in DataContext.UserSignatures
where x.UserName == user
select new
{
Signature = x.SignatureBase64
}).FirstOrDefault();
return(View(vm));
}
}
public IActionResult Delete()
{
int result = 0;
using (var DataContext = new DocumentEntities())
{
var db = DataContext.UserSignatures.FirstOrDefault(x => x.UserName == user);
DataContext.UserSignatures.Remove(db);
result = DataContext.SaveChanges();
}
return(Json(result));
}
public IActionResult Index()
{
using (var DataContext = new DocumentEntities())
{
var docs = (from x in DataContext.Documents
select new
{
Name = x.DocumentName,
ID = x.Id
}).ToList();
return(View(docs));
}
}
public static void AddContentData(int id, DocumentEntities context, Stream stream)
{
var rowData =
context.Database.SqlQuery <ContentStreamRowData>(RowDataStatement, new SqlParameter("id", id)).First();
using (var destination = new SqlFileStream(rowData.Path, rowData.Transaction, FileAccess.Write))
{
var buffer = new byte[16 * 1024];
int bytesRead;
while ((bytesRead = stream.Read(buffer, 0, buffer.Length)) > 0)
{
destination.Write(buffer, 0, bytesRead);
}
}
}
// DELETE api/collection/5
public async Task <IHttpActionResult> Delete(int id)
{
using (var context = new DocumentEntities())
{
var collection = await context.DocumentCollection.FirstOrDefaultAsync(c => c.Id == id && c.DeleteTime == null);
if (collection != null)
{
collection.DeleteTime = DateTime.Now;
context.SaveChanges();
return(Ok());
}
}
return(NotFound());
}
public IActionResult Details(int id)
{
using (var DataContext = new DocumentEntities())
{
DocumentActivity.RecordActivity(DocumentActivityOptions.Viewed, id, userid);
var doc = DataContext.Documents.First(x => x.Id == id);
var vm = new ViewModels.SignFileViewModel
{
DocumentID = doc.Id,
Filename = doc.DocumentName,
Base64 = doc.SignedBased64 ?? doc.Base64
};
return(View(vm));
}
}
private byte[] LoadImage(int id, out string type)
{
byte[] fileBytes = null;
string fileType = null;
using (DocumentEntities databaseContext = new DocumentEntities())
{
var databaseDocument = databaseContext.Documents.FirstOrDefault(doc => doc.DocumentId == id);
if (databaseDocument != null)
{
fileBytes = databaseDocument.FileContent;
fileType = databaseDocument.Type;
}
}
type = fileType;
return(fileBytes);
}
public async Task <IHttpActionResult> Delete(int id)
{
using (var context = new DocumentEntities())
{
var documentMeta = await context.DocumentMeta.FirstOrDefaultAsync(d => d.Id == id && d.DeleteTime == null);
if (documentMeta != null)
{
documentMeta.DeleteTime = DateTime.Now;
context.SaveChanges();
return(Ok());
}
}
return(NotFound());
}
// GET api/collection/5
public async Task <IHttpActionResult> GetCollection(int id)
{
using (var context = new DocumentEntities())
{
var collection = await context.DocumentCollection.Where(c => c.Id == id && c.DeleteTime == null)
.Select(c => new {
Id = c.Id,
Name = c.Name,
DocumentMeta = c.DocumentMeta.Where(d => d.DeleteTime == null)
}).FirstOrDefaultAsync();
if (collection != null)
{
return(Ok(collection));
}
}
return(NotFound());
}
public IActionResult SignImage(int id, int pageNumber, float x, float y)
{
using (var DataContext = new DocumentEntities())
{
DocumentActivity.RecordActivity(DocumentActivityOptions.Signed, id, userid);
var db = new DocumentEntities();
var file = Convert.FromBase64String(db.Documents.Find(id).Base64).ToArray();
var userSignature = DataContext.UserSignatures.FirstOrDefault(sig => sig.UserName == username).SignatureBase64;
var userSignatureBytes = Convert.FromBase64String(userSignature.Replace("image/png;base64,", ""));
var signedFile = PDFTool.SignFile(file, id, pageNumber, userSignatureBytes, x, y);
var doc = db.Documents.First(xx => xx.Id == id);
doc.SignedBased64 = signedFile;
db.SaveChanges();
return(Content(signedFile));
}
}
public static ByteArrayContent GetContentData(int id, DocumentEntities context, MemoryStream stream)
{
using (var tx = new TransactionScope())
{
var rowData =
context.Database.SqlQuery <ContentStreamRowData>(RowDataStatement, new SqlParameter("id", id)).First();
using (var source = new SqlFileStream(rowData.Path, rowData.Transaction, FileAccess.Read))
{
var buffer = new byte[16 * 1024];
int bytesRead;
while ((bytesRead = source.Read(buffer, 0, buffer.Length)) > 0)
{
stream.Write(buffer, 0, bytesRead);
}
}
tx.Complete();
}
return(new ByteArrayContent(stream.GetBuffer()));
}
public IActionResult Update(string signature)
{
using (var DataContext = new DocumentEntities())
{
var usersig = DataContext.UserSignatures.FirstOrDefault(x => x.UserName == user);
if (usersig == null)
{
DataContext.UserSignatures.Add(new UserSignature
{
SignatureBase64 = signature,
UserName = user
});
}
else
{
usersig.SignatureBase64 = signature;
}
DataContext.SaveChanges();
}
return(Json(signature));
}
public IActionResult UploadFile(IFormFile file, double x = 1, double y = 1)
{
var stream = new MemoryStream();
file.CopyTo(stream);
//string base64 = PDFTool.ConvertFile(file);
//string base64 = Libraries.GemBox.ConvertFile(file);
var db = new DocumentEntities();
var newDoc = new Document()
{
DocumentName = file.FileName,
Base64 = Convert.ToBase64String(stream.ToArray())
};
db.Documents.Add(newDoc);
db.SaveChanges();
DocumentActivity.RecordActivity(DocumentActivityOptions.Created, newDoc.Id, userid: 1);
return(Json(newDoc.Id));
}
public HttpResponseMessage Get(int id)
{
using (var context = new DocumentEntities())
{
var documentMeta = context.DocumentMeta.FirstOrDefault(d => d.Id == id && d.DeleteTime == null);
if (documentMeta == null)
{
return(new HttpResponseMessage(HttpStatusCode.NotFound));
}
var stream = new MemoryStream();
var result = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = DocumentContentHelper.GetContentData(id, context, stream)
};
result.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = documentMeta.FileName
};
result.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
return(result);
}
}
internal static CategorizedEntityCollection ConvertToCategorizedEntityCollection(DocumentEntities documentEntities)
{
return(new CategorizedEntityCollection(ConvertToCategorizedEntityList(documentEntities.Entities.ToList()), ConvertToWarnings(documentEntities.Warnings)));
}
