Example #1
0
        private async Task<HttpResponseMessage> SignDocumentAsync(SigningDocType signingDocType, Guid fileKey, string signatureXPath = null, IDictionary<string, string> signatureXPathNamespaces = null)
        {
            string serialNumber = System.Configuration.ConfigurationManager.AppSettings["Common.Api:CertificateSerialNumber"];
            string pinCode = System.Configuration.ConfigurationManager.AppSettings["Common.Api:CertificatePinCode"];

            using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["DbContext"].ConnectionString))
            {
                await connection.OpenAsync();

                Stream signedStream = null;
                using (var blobStream = new BlobReadStream(connection, "dbo", "Blobs", "Content", "Key", fileKey))
                {
                    if (signingDocType == SigningDocType.Xml)
                    {
                        XmlSigner xmlSigner = new XmlSigner(serialNumber, pinCode);
                        signedStream = xmlSigner.Sign(blobStream, Encoding.UTF8, signatureXPath, signatureXPathNamespaces);
                    }
                    else if (signingDocType == SigningDocType.Office)
                    {
                        OfficeSigner xmlSigner = new OfficeSigner(serialNumber, pinCode);

                        try
                        {
                            signedStream = new MemoryStream();
                            blobStream.CopyTo(signedStream);
                            signedStream.Position = 0;

                            xmlSigner.SignInPlace(signedStream);
                        }
                        catch (Exception)
                        {
                            signedStream.Dispose();
                            throw;
                        }
                    }
                }

                using (signedStream)
                {
                    using (var blobWriter = new BlobWriter(connection))
                    using (var stream = await blobWriter.OpenStreamAsync())
                    {
                        signedStream.Position = 0;
                        signedStream.CopyTo(stream);

                        var blobKey = blobWriter.GetBlobKey();

                        return Request.CreateResponse(HttpStatusCode.OK, new { fileKey = blobKey });
                    }
                }
            }
        }
 private Guid WriteToBlob(byte[] content)
 {
     using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["DbContext"].ConnectionString))
     {
         connection.Open();
         using (var blobWriter = new BlobWriter(connection))
         using (var stream = blobWriter.OpenStream())
         {
             stream.Write(content, 0, content.Length);
             return blobWriter.GetBlobKey();
         }
     }
 }
Example #3
0
        public IHttpActionResult CreateChildPubliclDoc(int id, NewPublicDocDO publicDoc)
        {
            using (var transaction = this.unitOfWork.BeginTransaction())
            {
                UnitUser unitUser = this.unitOfWork.DbContext.Set<UnitUser>().FirstOrDefault(e => e.UserId == this.userContext.UserId);

                ClassificationPermission managementPermission = this.classificationRepository.GetByAlias("Management");
                ClassificationPermission readPermission = this.classificationRepository.GetByAlias("Read");
                ClassificationPermission registerPermission = this.classificationRepository.GetByAlias("Register");

                bool hasManagementPermission =
                    this.classificationRepository.HasPermission(unitUser.UnitId, id, managementPermission.ClassificationPermissionId) &&
                    this.classificationRepository.HasPermission(unitUser.UnitId, id, readPermission.ClassificationPermissionId);

                if (!hasManagementPermission)
                {
                    return Unauthorized();
                }

                DocEntryType documentEntryType = this.unitOfWork.DbContext.Set<DocEntryType>()
                    .SingleOrDefault(e => e.Alias == "Document");
                DocDirection outgoingDocDirection = this.unitOfWork.DbContext.Set<DocDirection>()
                    .SingleOrDefault(e => e.Alias == "Outgoing");
                DocFormatType electronicDocFormatType = this.unitOfWork.DbContext.Set<DocFormatType>()
                    .SingleOrDefault(e => e.Alias == "Electronic");
                DocStatus draftStatus = this.unitOfWork.DbContext.Set<DocStatus>()
                    .SingleOrDefault(e => e.Alias == "Draft");
                DocCasePartType publicDocCasePartType = this.unitOfWork.DbContext.Set<DocCasePartType>()
                    .SingleOrDefault(e => e.Alias == "Public");
                DocType docType = this.unitOfWork.DbContext.Set<DocType>()
                    .SingleOrDefault(e => e.Alias.ToLower() == publicDoc.DocTypeAlias.ToLower());

                Doc newDoc = this.docRepository.CreateDoc(
                    outgoingDocDirection.DocDirectionId,
                    documentEntryType.DocEntryTypeId,
                    draftStatus.DocStatusId,
                    docType.Name,
                    publicDocCasePartType.DocCasePartTypeId,
                    null,
                    null,
                    docType.DocTypeId,
                    electronicDocFormatType.DocFormatTypeId,
                    null,
                    userContext);

                DocRelation parentDocRelation = this.unitOfWork.DbContext.Set<DocRelation>()
                    .FirstOrDefault(e => e.DocId == id);

                List<DocTypeUnitRole> docTypeUnitRoles = this.unitOfWork.DbContext.Set<DocTypeUnitRole>()
                    .Where(e => e.DocDirectionId == newDoc.DocDirectionId && e.DocTypeId == newDoc.DocTypeId)
                    .ToList();

                DocUnitRole importedBy = this.unitOfWork.DbContext.Set<DocUnitRole>()
                        .SingleOrDefault(e => e.Alias == "ImportedBy");

                List<DocClassification> parentDocClassifications = this.unitOfWork.DbContext.Set<DocClassification>()
                        .Where(e => e.DocId == parentDocRelation.DocId &&
                            e.IsActive &&
                            e.IsInherited)
                        .ToList();

                newDoc.CreateDocProperties(
                    parentDocRelation,
                    publicDocCasePartType.DocCasePartTypeId,
                    null,
                    parentDocClassifications,
                    null,
                    docTypeUnitRoles,
                    importedBy,
                    unitUser,
                    publicDoc.Correspondents,
                    null,
                    this.userContext);

                DocUnitRole from = this.unitOfWork.DbContext.Set<DocUnitRole>()
                    .SingleOrDefault(e => e.Alias == "From");

                newDoc.CreateDocUnit(unitUser.UnitId, from.DocUnitRoleId, this.userContext);

                DocUnitRole madeBy = this.unitOfWork.DbContext.Set<DocUnitRole>()
                    .SingleOrDefault(e => e.Alias == "MadeBy");

                newDoc.CreateDocUnit(unitUser.UnitId, madeBy.DocUnitRoleId, this.userContext);

                this.unitOfWork.Save();

                byte[] eDocFileContent = CreateRioObject(docType.ElectronicServiceFileTypeUri, parentDocRelation.RootDocId, id, newDoc);

                if (eDocFileContent != null)
                {
                    Guid eDocFileBlobKey = Guid.Empty;

                    using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["DbContext"].ConnectionString))
                    {
                        connection.Open();
                        using (var blobWriter = new BlobWriter(connection))
                        using (var stream = blobWriter.OpenStream())
                        {
                            stream.Write(eDocFileContent, 0, eDocFileContent.Length);
                            eDocFileBlobKey = blobWriter.GetBlobKey();
                        }
                    }

                    DocFileKind publicDocFileKind = this.unitOfWork.DbContext.Set<DocFileKind>().SingleOrDefault(e => e.Alias == "PublicAttachedFile");
                    DocFileOriginType editableDocFileOriginType = this.unitOfWork.DbContext.Set<DocFileOriginType>().SingleOrDefault(e => e.Alias == "EditableFile");
                    DocFileType docFileType = this.unitOfWork.DbContext.Set<DocFileType>().SingleOrDefault(e => e.DocTypeUri == docType.ElectronicServiceFileTypeUri);

                    newDoc.CreateDocFile(
                        publicDocFileKind.DocFileKindId,
                        docFileType.DocFileTypeId,
                        editableDocFileOriginType.DocFileOriginTypeId,
                        "Електронен документ",
                        "E-Document.xml",
                        String.Empty,
                        eDocFileBlobKey,
                        userContext);
                }

                this.unitOfWork.Save();

                this.docRepository.ExecSpSetDocTokens(docId: newDoc.DocId);
                this.docRepository.ExecSpSetDocUnitTokens(docId: newDoc.DocId);

                newDoc.SetReceiptOrder(this.docRepository.GetNextReceiptOrder(newDoc.DocId), this.userContext);

                bool hasRegisterPermission =
                    this.classificationRepository.HasPermission(unitUser.UnitId, newDoc.DocId, registerPermission.ClassificationPermissionId);
                if (!hasRegisterPermission)
                {
                    return Unauthorized();
                }

                this.unitOfWork.Save();

                transaction.Commit();

                return Ok(new
                {
                    docId = newDoc.DocId
                });
            }
        }
Example #4
0
        public IHttpActionResult CreateDoc(PreDocDO preDoc)
        {
            using (var transaction = this.unitOfWork.BeginTransaction())
            {
                UnitUser unitUser = this.unitOfWork.DbContext.Set<UnitUser>().FirstOrDefault(e => e.UserId == this.userContext.UserId);
                DocEntryType documentEntryType = this.unitOfWork.DbContext.Set<DocEntryType>().SingleOrDefault(e => e.Alias == "Document");
                DocFormatType electronicDocFormatType = this.unitOfWork.DbContext.Set<DocFormatType>().SingleOrDefault(e => e.Alias == "Electronic");
                DocStatus draftStatus = this.unitOfWork.DbContext.Set<DocStatus>().SingleOrDefault(e => e.Alias == "Draft");

                List<Doc> createdDocs = new List<Doc>();

                for (int i = 0; i < preDoc.DocNumbers; i++)
                {
                    Doc newDoc = this.docRepository.CreateDoc(
                        preDoc.DocDirectionId,
                        documentEntryType.DocEntryTypeId,
                        draftStatus.DocStatusId,
                        preDoc.DocSubject,
                        preDoc.DocCasePartTypeId,
                        null,
                        null,
                        preDoc.DocTypeId,
                        preDoc.DocFormatTypeId,
                        null,
                        userContext);

                    DocRelation parentDocRelation = null;
                    if (preDoc.ParentDocId.HasValue)
                    {
                        parentDocRelation = this.unitOfWork.DbContext.Set<DocRelation>().FirstOrDefault(e => e.DocId == preDoc.ParentDocId.Value);
                    }

                    ElectronicServiceStage electronicServiceStage = null;
                    if (parentDocRelation == null)
                    {
                        electronicServiceStage = this.unitOfWork.DbContext.Set<ElectronicServiceStage>()
                            .SingleOrDefault(e => e.DocTypeId == newDoc.DocTypeId && e.IsFirstByDefault);
                    }

                    List<DocTypeUnitRole> docTypeUnitRoles = this.unitOfWork.DbContext.Set<DocTypeUnitRole>()
                        .Where(e => e.DocDirectionId == newDoc.DocDirectionId && e.DocTypeId == newDoc.DocTypeId)
                        .ToList();

                    DocUnitRole importedBy = this.unitOfWork.DbContext.Set<DocUnitRole>()
                        .SingleOrDefault(e => e.Alias == "ImportedBy");

                    List<DocTypeClassification> docTypeClassifications = null;
                    List<DocClassification> parentDocClassifications = null;

                    if (parentDocRelation == null)
                    {
                        docTypeClassifications = this.unitOfWork.DbContext.Set<DocTypeClassification>()
                            .Where(e => e.DocDirectionId == newDoc.DocDirectionId &&
                                e.DocTypeId == newDoc.DocTypeId &&
                                e.IsActive)
                            .ToList();
                    }
                    else
                    {
                        parentDocClassifications = this.unitOfWork.DbContext.Set<DocClassification>()
                            .Where(e => e.DocId == parentDocRelation.DocId &&
                                e.IsActive &&
                                e.IsInherited)
                            .ToList();
                    }

                    newDoc.CreateDocProperties(
                        parentDocRelation,
                        preDoc.DocCasePartTypeId,
                        docTypeClassifications,
                        parentDocClassifications,
                        electronicServiceStage,
                        docTypeUnitRoles,
                        importedBy,
                        unitUser,
                        preDoc.Correspondents,
                        null,
                        this.userContext);

                    if (newDoc.IsCase)
                    {
                        this.docRepository.GenerateAccessCode(newDoc, this.userContext);
                    }

                    if (newDoc.DocFormatTypeId == electronicDocFormatType.DocFormatTypeId)
                    {
                        DocType docType = this.unitOfWork.DbContext.Set<DocType>().SingleOrDefault(e => e.DocTypeId == newDoc.DocTypeId);

                        byte[] eDocFileContent = CreateRioObject(docType.ElectronicServiceFileTypeUri, parentDocRelation != null ? parentDocRelation.RootDocId : null, preDoc.ParentDocId);

                        if (eDocFileContent != null)
                        {
                            Guid eDocFileBlobKey = Guid.Empty;

                            using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["DbContext"].ConnectionString))
                            {
                                connection.Open();
                                using (var blobWriter = new BlobWriter(connection))
                                using (var stream = blobWriter.OpenStream())
                                {
                                    stream.Write(eDocFileContent, 0, eDocFileContent.Length);
                                    eDocFileBlobKey = blobWriter.GetBlobKey();
                                }
                            }

                            DocFileKind publicDocFileKind = this.unitOfWork.DbContext.Set<DocFileKind>().SingleOrDefault(e => e.Alias == "PublicAttachedFile");
                            DocFileOriginType editableDocFileOriginType = this.unitOfWork.DbContext.Set<DocFileOriginType>().SingleOrDefault(e => e.Alias == "EditableFile");
                            DocFileType docFileType = this.unitOfWork.DbContext.Set<DocFileType>().SingleOrDefault(e => e.DocTypeUri == docType.ElectronicServiceFileTypeUri);

                            newDoc.CreateDocFile(
                                publicDocFileKind.DocFileKindId,
                                docFileType.DocFileTypeId,
                                editableDocFileOriginType.DocFileOriginTypeId,
                                "Електронен документ",
                                "E-Document.xml",
                                String.Empty,
                                eDocFileBlobKey,
                                userContext);
                        }
                    }

                    this.unitOfWork.Save();

                    this.docRepository.ExecSpSetDocTokens(docId: newDoc.DocId);
                    this.docRepository.ExecSpSetDocUnitTokens(docId: newDoc.DocId);

                    newDoc.SetReceiptOrder(this.docRepository.GetNextReceiptOrder(newDoc.DocId), this.userContext);

                    if (preDoc.Register)
                    {
                        ClassificationPermission registerPermission = this.classificationRepository.GetByAlias("Register");

                        bool hasRegisterPermission =
                            this.classificationRepository.HasPermission(unitUser.UnitId, newDoc.DocId, registerPermission.ClassificationPermissionId);

                        if (!hasRegisterPermission)
                        {
                            return BadRequest("Not enough permissions!");
                        }

                        this.docRepository.RegisterDoc(newDoc, unitUser, this.userContext);
                    }

                    this.unitOfWork.Save();

                    createdDocs.Add(newDoc);
                }

                transaction.Commit();

                if (createdDocs.Count == 1 && !preDoc.Register)
                {
                    return Ok(new
                        {
                            docId = createdDocs.FirstOrDefault().DocId
                        });
                }
                else
                {
                    string ids = Helper.GetStringFromIdList(createdDocs.Select(e => e.DocId).ToList());

                    return Ok(new
                        {
                            ids = ids
                        });
                }
            }
        }
Example #5
0
        public IHttpActionResult RegisterDoc(int id, string docVersion)
        {
            UnitUser unitUser = this.unitOfWork.DbContext.Set<UnitUser>().FirstOrDefault(e => e.UserId == this.userContext.UserId);

            ClassificationPermission registerPermission = this.classificationRepository.GetByAlias("Register");
            ClassificationPermission readPermission = this.classificationRepository.GetByAlias("Read");

            bool hasRegisterPermission =
                this.classificationRepository.HasPermission(unitUser.UnitId, id, registerPermission.ClassificationPermissionId) &&
                this.classificationRepository.HasPermission(unitUser.UnitId, id, readPermission.ClassificationPermissionId);

            if (!hasRegisterPermission)
            {
                return BadRequest("Not enough permissions!");
            }

            Doc doc = this.docRepository.Find(id,
                e => e.DocRelations);

            this.unitOfWork.DbContext.Set<DocFile>()
             .Include(e => e.DocFileOriginType)
             .Include(e => e.DocFileType)
             .Include(e => e.DocFileKind)
             .Where(e => e.DocId == id)
             .ToList();

            string result = this.docRepository.RegisterDoc(
                doc,
                unitUser,
                this.userContext,
                true,
                Helper.StringToVersion(docVersion));

            DocFile editable = doc.DocFiles.FirstOrDefault(e => e.DocFileOriginTypeId.HasValue && e.DocFileOriginType.Alias == "EditableFile");

            if (editable != null && editable.DocFileType.DocTypeUri != "Checklist")
            {
                using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["DbContext"].ConnectionString))
                {
                    connection.Open();

                    byte[] content;

                    using (MemoryStream m1 = new MemoryStream())
                    using (var blobStream = new BlobReadStream(connection, "dbo", "Blobs", "Content", "Key", editable.DocFileContentId))
                    {
                        blobStream.CopyTo(m1);
                        content = m1.ToArray();
                    }

                    content = AddRegistrationInfoToRioObject(content, editable.DocFileType.DocTypeUri, doc);

                    using (var blobWriter = new BlobWriter(connection))
                    using (var stream = blobWriter.OpenStream())
                    {
                        stream.Write(content, 0, content.Length);
                        editable.DocFileContentId = blobWriter.GetBlobKey();
                    }
                }
            }

            this.unitOfWork.Save();

            return Ok(new
            {
                result = result
            });
        }
Example #6
0
        public IHttpActionResult UpdateDoc(int id, DocDO doc)
        {
            using (var transaction = this.unitOfWork.BeginTransaction())
            {
                UnitUser unitUser = this.unitOfWork.DbContext.Set<UnitUser>().FirstOrDefault(e => e.UserId == this.userContext.UserId);

                ClassificationPermission editPermission = this.classificationRepository.GetByAlias("Edit");
                ClassificationPermission readPermission = this.classificationRepository.GetByAlias("Read");

                bool hasEditPermission =
                    this.classificationRepository.HasPermission(unitUser.UnitId, id, editPermission.ClassificationPermissionId) &&
                    this.classificationRepository.HasPermission(unitUser.UnitId, id, readPermission.ClassificationPermissionId);

                if (!hasEditPermission)
                {
                    return BadRequest("Not enough permissions!");
                }

                DateTime currentDate = DateTime.Now;
                var oldDoc = this.docRepository.Find(id,
                        e => e.DocCorrespondents,
                        e => e.DocFiles.Select(df => df.DocFileOriginType),
                        e => e.DocFiles.Select(df => df.DocFileType),
                        e => e.DocUnits);

                if (oldDoc == null)
                {
                    return NotFound();
                }

                oldDoc.EnsureForProperVersion(doc.Version);

                oldDoc.DocSourceTypeId = doc.DocSourceTypeId;
                oldDoc.DocSubject = doc.DocSubject;
                oldDoc.DocBody = doc.DocBody;
                oldDoc.CorrRegNumber = doc.CorrRegNumber;
                oldDoc.CorrRegDate = doc.CorrRegDate;
                oldDoc.AssignmentTypeId = doc.AssignmentTypeId;
                oldDoc.AssignmentDate = doc.AssignmentDate;
                oldDoc.AssignmentDeadline = doc.AssignmentDeadline;
                oldDoc.ModifyDate = DateTime.Now;
                oldDoc.ModifyUserId = userContext.UserId;

                #region DocUnits

                List<DocUnitRole> docUnitRoles = this.unitOfWork.DbContext.Set<DocUnitRole>().ToList();

                doc.DocUnitsFrom.ForEach(e => { e.ForeignKeyId = docUnitRoles.Single(p => p.Alias == "From").DocUnitRoleId; });
                doc.DocUnitsTo.ForEach(e => { e.ForeignKeyId = docUnitRoles.Single(p => p.Alias == "To").DocUnitRoleId; });
                doc.DocUnitsImportedBy.ForEach(e => { e.ForeignKeyId = docUnitRoles.Single(p => p.Alias == "ImportedBy").DocUnitRoleId; });
                doc.DocUnitsMadeBy.ForEach(e => { e.ForeignKeyId = docUnitRoles.Single(p => p.Alias == "MadeBy").DocUnitRoleId; });
                doc.DocUnitsCCopy.ForEach(e => { e.ForeignKeyId = docUnitRoles.Single(p => p.Alias == "CCopy").DocUnitRoleId; });
                doc.DocUnitsInCharge.ForEach(e => { e.ForeignKeyId = docUnitRoles.Single(p => p.Alias == "InCharge").DocUnitRoleId; });
                doc.DocUnitsControlling.ForEach(e => { e.ForeignKeyId = docUnitRoles.Single(p => p.Alias == "Controlling").DocUnitRoleId; });
                doc.DocUnitsReaders.ForEach(e => { e.ForeignKeyId = docUnitRoles.Single(p => p.Alias == "Readers").DocUnitRoleId; });
                doc.DocUnitsEditors.ForEach(e => { e.ForeignKeyId = docUnitRoles.Single(p => p.Alias == "Editors").DocUnitRoleId; });
                doc.DocUnitsRegistrators.ForEach(e => { e.ForeignKeyId = docUnitRoles.Single(p => p.Alias == "Registrators").DocUnitRoleId; });

                var allDocUnits = doc.DocUnitsTo.Union(
                    doc.DocUnitsFrom.Union(
                        doc.DocUnitsImportedBy.Union(
                            doc.DocUnitsMadeBy.Union(
                                doc.DocUnitsCCopy.Union(
                                    doc.DocUnitsInCharge.Union(
                                        doc.DocUnitsControlling.Union(
                                            doc.DocUnitsReaders.Union(
                                                doc.DocUnitsEditors.Union(
                                                    doc.DocUnitsRegistrators)))))))));

                var listDocUnits = oldDoc.DocUnits.ToList();

                for (var i = 0; i < listDocUnits.Count; i++)
                {
                    var matching = allDocUnits
                        .Where(e => e.NomValueId == listDocUnits[i].UnitId && e.ForeignKeyId == listDocUnits[i].DocUnitRoleId)
                        .ToList();

                    if (matching.Any())
                    {
                        matching.ForEach(e => { e.IsProcessed = true; });
                    }
                    else
                    {
                        oldDoc.DeleteDocUnit(listDocUnits[i], this.userContext);
                    }
                }
                foreach (var du in allDocUnits.Where(e => !e.IsProcessed))
                {
                    oldDoc.CreateDocUnit(du.NomValueId, du.ForeignKeyId, this.userContext);
                }

                #endregion

                #region DocCorrespondents

                var listDocCorrespondents = oldDoc.DocCorrespondents.ToList();

                for (var i = 0; i < listDocCorrespondents.Count; i++)
                {
                    var matching = doc.DocCorrespondents
                        .Where(e => e.NomValueId == listDocCorrespondents[i].CorrespondentId)
                        .ToList();

                    if (matching.Any())
                    {
                        matching.ForEach(e => { e.IsProcessed = true; });
                    }
                    else
                    {
                        oldDoc.DeleteDocCorrespondent(listDocCorrespondents[i], this.userContext);
                    }
                }
                foreach (var du in doc.DocCorrespondents.Where(e => !e.IsProcessed))
                {
                    oldDoc.CreateDocCorrespondent(du.NomValueId, this.userContext);
                }

                #endregion

                #region DocFiles

                DocFile editable = oldDoc.DocFiles.FirstOrDefault(e => e.DocFileOriginTypeId.HasValue && e.DocFileOriginType.Alias == "EditableFile");

                if (editable != null)
                {
                    byte[] content = null;

                    if (editable.DocFileType.DocTypeUri == "Checklist")
                    {
                        string contentStr = JsonConvert.SerializeObject(doc.JObject);
                        content = System.Text.Encoding.UTF8.GetBytes(contentStr);
                    }
                    else //doc is rio object
                    {
                        content = RioObjectUtils.GetBytesFromJObject(editable.DocFileType.DocTypeUri, doc.JObject);
                    }

                    using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["DbContext"].ConnectionString))
                    {
                        connection.Open();
                        using (var blobWriter = new BlobWriter(connection))
                        using (var stream = blobWriter.OpenStream())
                        {
                            stream.Write(content, 0, content.Length);
                            editable.DocFileContentId = blobWriter.GetBlobKey();
                        }
                    }
                }

                List<DocFileDO> allDocFiles = doc.DocFiles;
                List<DocFileType> docFileTypes = this.unitOfWork.DbContext.Set<DocFileType>().ToList();

                foreach (var file in allDocFiles.Where(e => !e.IsNew && e.IsDeleted && e.DocFileId.HasValue))
                {
                    oldDoc.DeleteDocFile(file.DocFileId.Value, this.userContext);
                }

                foreach (var file in allDocFiles.Where(e => !e.IsNew && !e.IsDeleted && e.IsDirty && e.DocFileId.HasValue))
                {
                    var docFileType = docFileTypes.FirstOrDefault(e => e.Extention == Path.GetExtension(file.File.Name));

                    if (docFileType == null)
                    {
                        docFileType = docFileTypes.FirstOrDefault(e => e.Alias == "UnknownBinary");
                    }

                    oldDoc.UpdateDocFile(file.DocFileId.Value, file.DocFileKindId, docFileType.DocFileTypeId, file.Name, file.File.Name, "", file.File.Key, userContext);
                }

                foreach (var file in allDocFiles.Where(e => e.IsNew && !e.IsDeleted))
                {
                    var docFileType = docFileTypes.FirstOrDefault(e => e.Extention == Path.GetExtension(file.File.Name));

                    if (docFileType == null)
                    {
                        docFileType = docFileTypes.FirstOrDefault(e => e.Alias == "UnknownBinary");
                    }

                    oldDoc.CreateDocFile(file.DocFileKindId, docFileType.DocFileTypeId, file.Name, file.File.Name, String.Empty, file.File.Key, userContext);
                }

                #endregion

                this.unitOfWork.Save();

                this.docRepository.ExecSpSetDocTokens(docId: oldDoc.DocId);
                this.docRepository.ExecSpSetDocUnitTokens(docId: oldDoc.DocId);

                transaction.Commit();

                return Ok();
            }
        }
Example #7
0
        public IHttpActionResult CreateChildReport(int id)
        {
            using (var transaction = this.unitOfWork.BeginTransaction())
            {
                int docId, checklistId;

                AopApp app = this.unitOfWork.DbContext.Set<AopApp>().Find(id);

                if (app.NDDocId.HasValue && app.NDChecklistId.HasValue)
                {
                    docId = app.NDDocId.Value;
                    checklistId = app.NDChecklistId.Value;
                }
                else
                {
                    throw new Exception("NDDocId OR NDChecklistId missing.");
                }

                UnitUser unitUser = this.unitOfWork.DbContext.Set<UnitUser>().FirstOrDefault(e => e.UserId == this.userContext.UserId);
                DocEntryType documentEntryType = this.unitOfWork.DbContext.Set<DocEntryType>().SingleOrDefault(e => e.Alias == "Document");

                DocDirection outgoingDocDirection = this.unitOfWork.DbContext.Set<DocDirection>()
                    .SingleOrDefault(e => e.Alias.ToLower() == "Outgoing".ToLower());
                DocCasePartType internalDocCasePartType = this.unitOfWork.DbContext.Set<DocCasePartType>()
                    .SingleOrDefault(e => e.Alias.ToLower() == "Internal".ToLower());
                DocFormatType paperDocFormatType = this.unitOfWork.DbContext.Set<DocFormatType>()
                    .SingleOrDefault(e => e.Alias.ToLower() == "Paper".ToLower());
                DocStatus draftStatus = this.unitOfWork.DbContext.Set<DocStatus>().SingleOrDefault(e => e.Alias == "Draft");

                DocType docType = this.unitOfWork.DbContext.Set<DocType>()
                    .SingleOrDefault(e => e.Alias.ToLower() == "Report".ToLower());
                string docSubject = "Генериран доклад";

                Doc newDoc = this.docRepository.CreateDoc(
                    outgoingDocDirection.DocDirectionId,
                    documentEntryType.DocEntryTypeId,
                    draftStatus.DocStatusId,
                    docSubject,
                    internalDocCasePartType.DocCasePartTypeId,
                    null,
                    null,
                    docType.DocTypeId,
                    paperDocFormatType.DocFormatTypeId,
                    null,
                    userContext);

                DocRelation parentDocRelation = this.unitOfWork.DbContext.Set<DocRelation>().FirstOrDefault(e => e.DocId == docId);

                ElectronicServiceStage electronicServiceStage = null;
                if (parentDocRelation == null)
                {
                    electronicServiceStage = this.unitOfWork.DbContext.Set<ElectronicServiceStage>()
                        .SingleOrDefault(e => e.DocTypeId == newDoc.DocTypeId && e.IsFirstByDefault);
                }

                List<DocUnitRole> docUnitRoles = this.unitOfWork.DbContext.Set<DocUnitRole>().ToList();

                List<DocTypeUnitRole> docTypeUnitRoles = new List<DocTypeUnitRole>();

                //from
                docTypeUnitRoles.Add(new DocTypeUnitRole
                {
                    DocTypeId = docType.DocTypeId,
                    DocDirectionId = outgoingDocDirection.DocDirectionId,
                    DocUnitRoleId = docUnitRoles.SingleOrDefault(e => e.Alias == "From").DocUnitRoleId,
                    UnitId = unitUser.UnitId,
                    IsActive = true
                });

                DocUnitRole importedBy = docUnitRoles.SingleOrDefault(e => e.Alias == "ImportedBy");

                List<DocClassification> parentDocClassifications = this.unitOfWork.DbContext.Set<DocClassification>()
                       .Where(e => e.DocId == parentDocRelation.DocId &&
                           e.IsActive &&
                           e.IsInherited)
                       .ToList();

                Doc caseDoc = this.docRepository.Find(this.docRepository.GetCaseId(docId),
                    e => e.DocCorrespondents);

                List<int> correspondentIds = caseDoc.DocCorrespondents.Select(e => e.CorrespondentId).ToList();

                newDoc.CreateDocProperties(
                    parentDocRelation,
                    null,
                    null,
                    parentDocClassifications,
                    electronicServiceStage,
                    docTypeUnitRoles,
                    importedBy,
                    unitUser,
                    correspondentIds,
                    null,
                    this.userContext);

                this.unitOfWork.Save();

                #region FileContent

                DocFile docFile = this.unitOfWork.DbContext.Set<DocFile>()
                    .FirstOrDefault(e => e.DocId == checklistId && e.DocFileOriginTypeId.HasValue && e.DocFileOriginType.Alias == "EditableFile");
                DocFileType docFileType = this.unitOfWork.DbContext.Set<DocFileType>().SingleOrDefault(e => e.Alias == "DOCX");
                DocFileKind docFileKind = this.unitOfWork.DbContext.Set<DocFileKind>().Single(e => e.Alias == "PublicAttachedFile");
                DocFileOriginType docFileOriginType = this.unitOfWork.DbContext.Set<DocFileOriginType>().Single(e => e.Alias == "AttachedFile");

                Guid blobKey;

                byte[] content;

                using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["DbContext"].ConnectionString))
                {
                    connection.Open();

                    using (MemoryStream m1 = new MemoryStream())
                    using (var blobStream = new BlobReadStream(connection, "dbo", "Blobs", "Content", "Key", docFile.DocFileContentId))
                    {
                        blobStream.CopyTo(m1);
                        content = m1.ToArray();
                    }

                    string contentToString = System.Text.Encoding.UTF8.GetString(content);
                    JObject checklistObj = JsonConvert.DeserializeObject<JObject>(contentToString);
                    JArray checklistVersions = checklistObj["versions"] as JArray;
                    JObject lastest = checklistVersions.First() as JObject;

                    DocUnit checklistMadeBy = this.unitOfWork.DbContext.Set<DocUnit>()
                        .Include(e => e.Unit.UnitRelations.Select(u => u.ParentUnit))
                        .Include(e => e.DocUnitRole)
                        .FirstOrDefault(e => e.DocId == checklistId && (e.DocUnitRole.Alias == "ImportedBy" || e.DocUnitRole.Alias == "MadeBy"));

                    DocWorkflow checklistDiscuss = this.unitOfWork.DbContext.Set<DocWorkflow>()
                        .Include(e => e.PrincipalUnit.UnitRelations.Select(u => u.ParentUnit))
                        .FirstOrDefault(e => e.DocId == checklistId && e.DocWorkflowAction.Alias == "Discuss");

                    JObject json = this.dataGenerator.GenerateReport(lastest,
                        date: DateTime.Now.ToString("dd.MM.yyyy"),
                        madeByName: checklistMadeBy != null ? checklistMadeBy.Unit.Name : string.Empty,
                        madeByPosition: checklistMadeBy != null ? checklistMadeBy.Unit.UnitRelations.First().ParentUnit.Name : string.Empty,
                        coordinatorName: checklistDiscuss != null ? checklistDiscuss.PrincipalUnit.Name : string.Empty,
                        coordinatorPosition: checklistDiscuss != null ? checklistDiscuss.PrincipalUnit.UnitRelations.First().ParentUnit.Name : string.Empty
                        );

                    string templatePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"App\word_templates\doklad_template.docx");

                    using (FileStream template = File.Open(templatePath, FileMode.Open, FileAccess.Read))
                    using (var memoryStream = new MemoryStream())
                    using (var blobWriter = new BlobWriter(connection))
                    using (var stream = blobWriter.OpenStream())
                    {
                        template.CopyTo(memoryStream);

                        WordTemplateTransformer tt = new WordTemplateTransformer(memoryStream);
                        tt.Transform(json);

                        memoryStream.Position = 0;
                        memoryStream.CopyTo(stream);

                        blobKey = blobWriter.GetBlobKey();
                    }
                }

                newDoc.CreateDocFile(
                    docFileKind.DocFileKindId,
                    docFileType.DocFileTypeId,
                    docFileOriginType.DocFileOriginTypeId,
                    "Report.docx",
                    "Report.docx",
                    "",
                    blobKey,
                    this.userContext);

                #endregion

                app.NDReportId = newDoc.DocId;

                this.docRepository.ExecSpSetDocTokens(docId: newDoc.DocId);
                this.docRepository.ExecSpSetDocUnitTokens(docId: newDoc.DocId);

                this.unitOfWork.Save();

                transaction.Commit();

                return Ok(new
                {
                    docId = newDoc.DocId
                });
            }
        }
Example #8
0
        public IHttpActionResult CreateChildChecklist(int id, string identifier, string action)
        {
            using (var transaction = this.unitOfWork.BeginTransaction())
            {
                bool copy = false, correct = false;
                int docId;
                int checklistId = 0;

                AopApp app = this.unitOfWork.DbContext.Set<AopApp>().Find(id);

                if (identifier == "st")
                {
                    if (app.STDocId.HasValue)
                    {
                        docId = app.STDocId.Value;
                    }
                    else
                    {
                        throw new Exception("STDocId missing.");
                    }

                    if (action == "copy")
                    {
                        copy = true;

                        if (!app.STChecklistId.HasValue)
                        {
                            throw new Exception();
                        }

                        checklistId = app.STChecklistId.Value;
                    }
                    else if (action == "correct")
                    {
                        correct = true;

                        if (!app.STChecklistId.HasValue)
                        {
                            throw new Exception();
                        }

                        checklistId = app.STChecklistId.Value;
                    }
                }
                else if (identifier == "nd")
                {
                    if (app.NDDocId.HasValue)
                    {
                        docId = app.NDDocId.Value;
                    }
                    else
                    {
                        throw new Exception("NDDocId missing.");
                    }

                    if (action == "copy")
                    {
                        copy = true;

                        if (!app.NDChecklistId.HasValue && !app.STChecklistId.HasValue)
                        {
                            throw new Exception();
                        }

                        if (app.NDChecklistId.HasValue)
                        {
                            checklistId = app.NDChecklistId.Value;
                        }
                        else if (app.STChecklistId.HasValue)
                        {
                            checklistId = app.STChecklistId.Value;
                        }
                    }
                    else if (action == "correct")
                    {
                        correct = true;

                        if (!app.NDChecklistId.HasValue)
                        {
                            throw new Exception();
                        }

                        checklistId = app.NDChecklistId.Value;
                    }
                }
                else
                {
                    throw new Exception("Identifier missing.");
                }

                UnitUser unitUser = this.unitOfWork.DbContext.Set<UnitUser>().Include(e => e.Unit).FirstOrDefault(e => e.UserId == this.userContext.UserId);
                DocEntryType documentEntryType = this.unitOfWork.DbContext.Set<DocEntryType>().SingleOrDefault(e => e.Alias == "Document");

                if (correct)
                {
                    documentEntryType = this.unitOfWork.DbContext.Set<DocEntryType>().SingleOrDefault(e => e.Alias == "Resolution");
                }

                DocDirection internalDocDirection = this.unitOfWork.DbContext.Set<DocDirection>()
                    .SingleOrDefault(e => e.Alias.ToLower() == "Internal".ToLower());
                DocCasePartType internalDocCasePartType = this.unitOfWork.DbContext.Set<DocCasePartType>()
                    .SingleOrDefault(e => e.Alias.ToLower() == "Internal".ToLower());
                DocFormatType paperDocFormatType = this.unitOfWork.DbContext.Set<DocFormatType>()
                    .SingleOrDefault(e => e.Alias.ToLower() == "Paper".ToLower());
                DocStatus draftStatus = this.unitOfWork.DbContext.Set<DocStatus>().SingleOrDefault(e => e.Alias == "Draft");

                DocType docType = this.unitOfWork.DbContext.Set<DocType>()
                    .SingleOrDefault(e => e.Alias.ToLower() == "EditableDocumentFile".ToLower());
                string docSubject = "Чеклист";

                if (identifier == "st")
                {
                    docSubject = "Чеклист за първи етап";
                }
                else
                {
                    docSubject = "Чеклист за втори етап";
                }

                if (correct)
                {
                    docType = this.unitOfWork.DbContext.Set<DocType>().SingleOrDefault(e => e.Alias == "Resolution");
                    docSubject = "Поправка на " + docSubject.ToLower();
                }
                else if (copy)
                {
                    docSubject = "Копие на " + docSubject.ToLower();
                }

                Doc newDoc = this.docRepository.CreateDoc(
                    internalDocDirection.DocDirectionId,
                    documentEntryType.DocEntryTypeId,
                    draftStatus.DocStatusId,
                    docSubject,
                    internalDocCasePartType.DocCasePartTypeId,
                    null,
                    null,
                    docType.DocTypeId,
                    paperDocFormatType.DocFormatTypeId,
                    null,
                    userContext);

                DocRelation parentDocRelation = this.unitOfWork.DbContext.Set<DocRelation>().FirstOrDefault(e => e.DocId == docId);

                if (copy || correct)
                {
                    if (parentDocRelation.ParentDocId.HasValue)
                    {
                        parentDocRelation = this.unitOfWork.DbContext.Set<DocRelation>().FirstOrDefault(e => e.DocId == parentDocRelation.ParentDocId.Value);
                    }
                }

                ElectronicServiceStage electronicServiceStage = null;
                if (parentDocRelation == null)
                {
                    electronicServiceStage = this.unitOfWork.DbContext.Set<ElectronicServiceStage>()
                        .SingleOrDefault(e => e.DocTypeId == newDoc.DocTypeId && e.IsFirstByDefault);
                }

                List<DocUnitRole> docUnitRoles = this.unitOfWork.DbContext.Set<DocUnitRole>().ToList();

                List<DocTypeUnitRole> docTypeUnitRoles = new List<DocTypeUnitRole>();

                //from
                docTypeUnitRoles.Add(new DocTypeUnitRole
                {
                    DocTypeId = docType.DocTypeId,
                    DocDirectionId = internalDocDirection.DocDirectionId,
                    DocUnitRoleId = docUnitRoles.SingleOrDefault(e => e.Alias == "From").DocUnitRoleId,
                    UnitId = unitUser.UnitId,
                    IsActive = true
                });

                DocUnitRole importedBy = docUnitRoles.SingleOrDefault(e => e.Alias == "ImportedBy");

                if (correct)
                {
                    List<DocUnit> checklistImporters = this.unitOfWork.DbContext.Set<DocUnit>()
                        .Where(e => e.DocId == checklistId && e.DocUnitRoleId == importedBy.DocUnitRoleId)
                        .ToList();

                    foreach (var item in checklistImporters)
                    {
                        //InCharge
                        docTypeUnitRoles.Add(new DocTypeUnitRole
                        {
                            DocTypeId = docType.DocTypeId,
                            DocDirectionId = internalDocDirection.DocDirectionId,
                            DocUnitRoleId = docUnitRoles.SingleOrDefault(e => e.Alias == "InCharge").DocUnitRoleId,
                            UnitId = item.UnitId,
                            IsActive = true
                        });
                    }

                    AssignmentType noDeadline = this.unitOfWork.DbContext.Set<AssignmentType>()
                        .SingleOrDefault(e => e.Alias == "WithoutDeadline");

                    newDoc.AssignmentTypeId = noDeadline.AssignmentTypeId;
                    newDoc.AssignmentDate = DateTime.Now;
                }

                List<DocClassification> parentDocClassifications = this.unitOfWork.DbContext.Set<DocClassification>()
                        .Where(e => e.DocId == parentDocRelation.DocId &&
                            e.IsActive &&
                            e.IsInherited)
                        .ToList();

                newDoc.CreateDocProperties(
                    parentDocRelation,
                    null,
                    null,
                    parentDocClassifications,
                    electronicServiceStage, //? should there be a stage
                    docTypeUnitRoles,
                    importedBy,
                    unitUser,
                    null,
                    null,
                    this.userContext);

                Guid blobKey;

                string emptyChecklist = JsonConvert.SerializeObject(new
                {
                    version = "1",
                    author = unitUser.Unit.Name,
                    createDate = DateTime.Now
                }).ToString();

                string contentStr = string.Format("{{ versions: [{0}] }}", emptyChecklist);

                if (!copy && !correct)
                {
                    Doc doc = this.docRepository.Find(docId, e => e.DocFiles);

                    var fedFile = doc.DocFiles.FirstOrDefault(e => e.DocFileName.EndsWith(".fed"));

                    if (fedFile != null)
                    {
                        byte[] fedContent;

                        using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["DbContext"].ConnectionString))
                        {
                            connection.Open();

                            using (MemoryStream m1 = new MemoryStream())
                            using (var blobStream = new BlobReadStream(connection, "dbo", "Blobs", "Content", "Key", fedFile.DocFileContentId))
                            {
                                blobStream.CopyTo(m1);
                                fedContent = m1.ToArray();
                            }
                        }

                        List<NOMv5.nom> noms = FedHelper.GetFedDocumentNomenclatures();
                        List<NUTv5.item> nuts = FedHelper.GetFedDocumentNuts();

                        FEDv5.document fedDoc = XmlSerializerUtils.XmlDeserializeFromBytes<FEDv5.document>(fedContent);

                        FedExtractor.noms = noms;

                        string contractor = FedExtractor.GetContractor(fedDoc);
                        string contractorLotNum = FedExtractor.GetContractorBatch(fedDoc);

                        string procType = FedExtractor.GetProcedureTypeShort(fedDoc);
                        string obj = FedExtractor.GetObject(fedDoc);
                        string criteria = FedExtractor.GetOffersCriteriaOnly(fedDoc);
                        string subject = FedExtractor.GetSubject(fedDoc);
                        string val = FedExtractor.GetPredictedValue(fedDoc);

                        string fedValueChecklist = JsonConvert.SerializeObject(new
                        {
                            version = "1",
                            author = unitUser.Unit.Name,
                            createDate = DateTime.Now,
                            paragraph1 = new
                            {
                                employer = new
                                {
                                    table1 = new
                                    {
                                        row1 = contractor,
                                        row3 = contractorLotNum
                                    }
                                },
                                proc = new
                                {
                                    table1 = new
                                    {
                                        row1 = new
                                        {
                                            tick1 = procType == "Открита" ? true : false,
                                            tick2 = procType == "Ограничена" ? true : false,
                                            tick3 = procType == "Ускорена ограничена" ? true : false,
                                            tick4 = procType == "Договаряне" ? true : false,
                                            tick5 = procType == "Ускорена процедура на договаряне" || procType == "Ускорена на договаряне" ? true : false,
                                            tick6 = procType == "Състезателен диалог" ? true : false,
                                        },
                                        row2 = new
                                        {
                                            tick1 = obj == "Строителство" ? true : false,
                                            tick2 = obj == "Доставки" ? true : false,
                                            tick3 = obj == "Услуги" ? true : false
                                        },
                                        row4 = subject,
                                        row5 = val,
                                        row7 = new
                                        {
                                            tick1 = obj.ToLower() == "най-ниска цена" ? true : false,
                                            tick2 = obj == "икономически най-изгодна оферта с оглед на" || obj == "икономически най-изгодна оферта при" ? true : false
                                        }
                                    }
                                }
                            }
                        }).ToString();

                        contentStr = string.Format("{{ versions: [{0}] }}", fedValueChecklist);
                    }
                }

                if (copy || correct)
                {
                    DocFile editable = this.unitOfWork.DbContext.Set<DocFile>().FirstOrDefault(e => e.DocId == checklistId && e.DocFileOriginType.Alias == "EditableFile");

                    if (editable != null)
                    {
                        byte[] contentToBeCopied;

                        using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["DbContext"].ConnectionString))
                        {
                            connection.Open();

                            using (MemoryStream m1 = new MemoryStream())
                            using (var blobStream = new BlobReadStream(connection, "dbo", "Blobs", "Content", "Key", editable.DocFileContentId))
                            {
                                blobStream.CopyTo(m1);
                                contentToBeCopied = m1.ToArray();
                            }
                        }

                        string contentToString = System.Text.Encoding.UTF8.GetString(contentToBeCopied);

                        JObject checklistObj = JsonConvert.DeserializeObject<JObject>(contentToString);
                        JArray checklistVersions = checklistObj["versions"] as JArray;
                        dynamic newChecklistVersion = checklistVersions.First().DeepClone();
                        newChecklistVersion.version = int.Parse(Convert.ToString(newChecklistVersion.version)) + 1;
                        newChecklistVersion.author = unitUser.Unit.Name;
                        newChecklistVersion.createDate = DateTime.Now;

                        checklistVersions.Insert(0, newChecklistVersion);

                        contentStr = JsonConvert.SerializeObject(checklistObj);
                    }
                }

                byte[] content = System.Text.Encoding.UTF8.GetBytes(contentStr);

                using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["DbContext"].ConnectionString))
                {
                    connection.Open();
                    using (var blobWriter = new BlobWriter(connection))
                    using (var stream = blobWriter.OpenStream())
                    {
                        stream.Write(content, 0, content.Length);
                        blobKey = blobWriter.GetBlobKey();
                    }
                }

                DocFileKind privateKind = this.unitOfWork.DbContext.Set<DocFileKind>()
                    .FirstOrDefault(e => e.Alias == "PrivateAttachedFile");
                DocFileType unknownType = this.unitOfWork.DbContext.Set<DocFileType>()
                    .FirstOrDefault(e => e.Alias == "Checklist");
                DocFileOriginType editableFile = this.unitOfWork.DbContext.Set<DocFileOriginType>()
                    .FirstOrDefault(e => e.Alias == "EditableFile");

                newDoc.CreateDocFile(
                    privateKind.DocFileKindId,
                    unknownType.DocFileTypeId,
                    editableFile.DocFileOriginTypeId,
                    "Checklist",
                    "Checklist",
                    "",
                    blobKey,
                    this.userContext);

                this.unitOfWork.Save();

                if (identifier == "st")
                {
                    app.STChecklistId = newDoc.DocId;
                }
                else if (identifier == "nd")
                {
                    app.NDChecklistId = newDoc.DocId;
                }

                this.docRepository.ExecSpSetDocTokens(docId: newDoc.DocId);
                this.docRepository.ExecSpSetDocUnitTokens(docId: newDoc.DocId);

                this.unitOfWork.Save();

                transaction.Commit();

                return Ok(new
                {
                    docId = newDoc.DocId
                });
            }
        }
Example #9
0
        public void StartUploading(
            //intput
            BlockingCollection<Tuple<int, MemoryStream>> blobContents,
            RateLimiter rateLimiter,
            //output
            ConcurrentDictionary<int, string> blobIdsToFileKeys,
            BlockingCollection<long> uploadedBytes,
            //cancellation
            CancellationTokenSource cts,
            CancellationToken ct)
        {
            try
            {
                this.sqlConn.Open();
            }
            catch (Exception)
            {
                cts.Cancel();
                throw;
            }

            foreach (var blobContent in blobContents.GetConsumingEnumerable())
            {
                ct.ThrowIfCancellationRequested();

                var blobId = blobContent.Item1;
                var content = blobContent.Item2;

                try
                {
                    using (var blobWriter = new BlobWriter(sqlConn))
                    {
                        long length;
                        using (var stream = blobWriter.OpenStream())
                        using (content)
                        {
                            length = content.Length;
                            content.CopyTo(stream);
                        }

                        if (!blobIdsToFileKeys.TryAdd(blobId, blobWriter.GetBlobKey().ToString()))
                        {
                            throw new Exception("blobId already present in dictionary");
                        }

                        rateLimiter.Decrement(length);
                        uploadedBytes.Add(length);
                    }
                }
                catch (Exception)
                {
                    cts.Cancel();
                    throw;
                }
            }
        }
Example #10
0
        public Guid SaveStreamToBlob(Stream stream, string connectionString)
        {
            Guid licenceEditionDocBlobKey;

            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                connection.Open();
                using (var blobWriter = new BlobWriter(connection))
                using (var blobStream = blobWriter.OpenStream())
                {
                    stream.CopyTo(blobStream);
                    licenceEditionDocBlobKey = blobWriter.GetBlobKey();
                }
            }

            return licenceEditionDocBlobKey;
        }
Example #11
0
        public IHttpActionResult PostExtractPages(string fileKey, string name)
        {
            using (var transaction = this.unitOfWork.BeginTransaction())
            {
                GhostscriptVersionInfo lastInstalledVersion = GhostscriptVersionInfo.GetLastInstalledVersion(GhostscriptLicense.GPL | GhostscriptLicense.AFPL, GhostscriptLicense.GPL);
                List<GvaFile> gvaFiles = new List<GvaFile>();
                int pageCount;

                using (MemoryStream m1 = new MemoryStream())
                {
                    using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["DbContext"].ConnectionString))
                    {
                        connection.Open();

                        using (var blobStream = new BlobReadStream(connection, "dbo", "Blobs", "Content", "Key", fileKey))
                        {
                            blobStream.CopyTo(m1);
                        }
                    }

                    using (GhostscriptRasterizer rasterizer = new GhostscriptRasterizer())
                    {
                        rasterizer.Open(m1, lastInstalledVersion, false);
                        pageCount = rasterizer.PageCount;

                        for (int i = 1; i <= pageCount; i++)
                        {
                            using (var ms = new MemoryStream())
                            {
                                GvaFile file = null;

                                Image img = rasterizer.GetPage(300, 300, i);
                                img.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg);

                                using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["DbContext"].ConnectionString))
                                {
                                    connection.Open();
                                    using (var blobWriter = new BlobWriter(connection))
                                    using (var stream = blobWriter.OpenStream())
                                    {
                                        stream.Write(ms.ToArray(), 0, (int)ms.Length);

                                        file = new GvaFile()
                                        {
                                            Filename = Path.Combine(Path.GetFileNameWithoutExtension(name) + "-" + i.ToString() + ".jpg"),
                                            MimeType = "image/jpeg",
                                            FileContentId = blobWriter.GetBlobKey()
                                        };

                                        this.unitOfWork.DbContext.Set<GvaFile>().Add(file);
                                        gvaFiles.Add(file);
                                    }
                                }
                            }
                        }
                    }
                }

                this.unitOfWork.Save();
                transaction.Commit();

                List<int> gvaFileIds = gvaFiles.Select(e => e.GvaFileId).ToList();

                return Ok(new { pageCount = pageCount, gvaFileIds = gvaFileIds });
            }
        }