Example #1
0
        public void Save()
        {
            string content        = Serialize();
            var    document       = new dbDocument();
            var    dao            = new DocumentDAO();
            bool   documentExists = dao.hasDocument(uuid);

            //if( !documentExists )
            //    LogManager.Trace("Creating new Test Adapter Description with uuid of {0}", uuid);
            //else
            //    LogManager.Trace("Saving Test Adapter Description with uuid of {0}", uuid);

            document.contentType         = "text/xml";
            document.documentDescription = "Test Adapter";
            document.documentName        = Identification.ModelName;
            document.documentVersion     = version;
            document.documentSize        = content.Length;
            document.documentTypeId      = (int)dbDocument.DocumentType.TEST_ADAPTER_DESCRIPTION;
            document.documentContent     = Encoding.UTF8.GetBytes(content);
            document.UUID      = Guid.Parse(uuid);
            document.DataState = documentExists ? BASEBean.eDataState.DS_EDIT : BASEBean.eDataState.DS_ADD;
            document.save();

            foreach (IdentificationNumber idNumber in Identification.IdentificationNumbers)
            {
                string type   = Enum.GetName(typeof(IdentificationNumberType), idNumber.type);
                string number = idNumber.number;
                var    asset  = new AssetIdentificationBean();
                asset.assetNumber = number;
                asset.assetType   = type;
                asset.uuid        = Guid.Parse(uuid);
                asset.DetermineDataState();
                asset.save();
            }
        }
Example #2
0
        /**
         * Call this method to save the document data to the database.
         */
        private static void SaveInstrumentDescriptionDocument(InstrumentDescription instrumentDescription,
                                                              Document document,
                                                              BASEBean.eDataState dataState)
        {
            var    dbDocument = new dbDocument();
            String xml        = instrumentDescription.Serialize();

            document.DocumentContent = dbDocument.documentContent = Encoding.UTF8.GetBytes(xml);
            dbDocument.documentSize  = xml.Length;
            document.ContentType     = dbDocument.contentType = ATMLContext.CONTEXT_TYPE_XML;
            dbDocument.DataState     = dataState;
            if (dataState == BASEBean.eDataState.DS_ADD)
            {
                dbDocument.dateAdded = DateTime.UtcNow;
            }
            else if (dataState == BASEBean.eDataState.DS_EDIT)
            {
                dbDocument.dateUpdated = DateTime.UtcNow;
            }
            document.Description      = dbDocument.documentDescription = instrumentDescription.Description;
            dbDocument.documentTypeId = (int)dbDocument.DocumentType.INSTRUMENT_DESCRIPTION;
            document.DocumentType     = dbDocument.DocumentType.INSTRUMENT_DESCRIPTION;
            document.version          = dbDocument.documentVersion = instrumentDescription.version;
            document.name             = dbDocument.documentName = instrumentDescription.Identification.ModelName;
            dbDocument.UUID           = Guid.Parse(instrumentDescription.uuid);
            document.uuid             = instrumentDescription.uuid;
            dbDocument.save();
        }
Example #3
0
        public static void SaveDocument(DocumentReference docRef)
        {
            bool newDocument = false;

            if (String.IsNullOrEmpty(docRef.uuid))
            {
                docRef.uuid = Guid.NewGuid().ToString();
            }

            //-------------------------------------------------//
            //--- We will save to the database at this time ---//
            //-------------------------------------------------//
            DocumentDAO documentDAO = DataManager.getDocumentDAO();
            var         document    = new dbDocument();

            if (documentDAO.hasDocument(docRef.uuid))
            {
                document             = documentDAO.openDatabaseDocument(docRef.uuid);
                document.DataState   = BASEBean.eDataState.DS_EDIT;
                document.dateUpdated = DateTime.UtcNow;
            }
            else
            {
                document.DataState = BASEBean.eDataState.DS_ADD;
                document.dateAdded = DateTime.UtcNow;
                newDocument        = true;
            }

            document.documentContent = docRef.DocumentContent;
            document.documentName    = docRef.DocumentName;
            document.documentSize    = docRef.DocumentContent.Length;
            document.contentType     = docRef.ContentType;
            document.save();
            LogManager.Trace("Referenced Document {0} has been {1}", document.documentName,
                             newDocument ? "Added" : "Saved");
        }
Example #4
0
        public static void SaveDocument(Document doc)
        {
            bool hasLocalTransaction = false;

            //------------------------------------------------------------//
            //--- Only save to the database if the content is not null ---//
            //------------------------------------------------------------//
            BASEBean.eDataState stateId;
            if (doc.DocumentContent != null)
            {
                if (String.IsNullOrEmpty(doc.uuid))
                {
                    doc.uuid = Guid.NewGuid().ToString();
                }

                //-------------------------------------------------//
                //--- We will save to the database at this time ---//
                //-------------------------------------------------//
                DocumentDAO documentDAO = DataManager.getDocumentDAO();
                try
                {
                    if (!documentDAO.IsInTransaction)
                    {
                        documentDAO.StartTransaction();
                        hasLocalTransaction = true;
                    }
                    var  document          = new dbDocument();
                    bool hasDocumentByUuid = documentDAO.hasDocument(doc.uuid);
                    bool hasDocumentByName = documentDAO.hasDocument(doc.name, (int)doc.DocumentType);
                    if (hasDocumentByName != hasDocumentByUuid)
                    {
                        string msg =
                            "There is an inconsistancy with the document uuid and the internal uuid for the device, please correct.";
                        MessageBox.Show(msg, @"E R R O R");
                        throw new Exception(msg);
                    }

                    if (hasDocumentByUuid)
                    {
                        document = documentDAO.openDatabaseDocument(doc.uuid);
                        stateId  = document.DataState = (doc.DataState == BASEBean.eDataState.DS_DELETE
                                                             ? BASEBean.eDataState.DS_DELETE
                                                             : BASEBean.eDataState.DS_EDIT);
                        document.dateUpdated = DateTime.UtcNow;
                    }
                    else
                    {
                        stateId            = document.DataState = BASEBean.eDataState.DS_ADD;
                        document.dateAdded = DateTime.UtcNow;
                    }

                    int assetsDeleted = 0;
                    if (stateId == BASEBean.eDataState.DS_DELETE)
                    {
                        if (documentDAO.HasAssets(doc.uuid))
                        {
                            assetsDeleted = documentDAO.DeleteAssets(doc.uuid);
                        }
                    }
                    document.UUID = Guid.Parse(doc.uuid);
                    document.documentDescription = doc.Description;
                    document.documentTypeId      = (int)doc.DocumentType;
                    document.documentContent     = doc.DocumentContent;
                    document.documentName        = doc.name;
                    document.documentSize        = doc.DocumentContent.Length;
                    document.contentType         = doc.ContentType;
                    document.crc = doc.Crc32;
                    document.save();
                    if (hasLocalTransaction)
                    {
                        documentDAO.CommitTransaction();
                    }
                    LogManager.Trace("Document {0} has been {1}",
                                     document.documentName,
                                     stateId == BASEBean.eDataState.DS_ADD
                                          ? "Added"
                                          : stateId == BASEBean.eDataState.DS_DELETE
                                                ? "Deleted"
                                                : "Saved");
                    if (assetsDeleted > 0)
                    {
                        LogManager.Trace("Deleted {0} associated assets.", assetsDeleted);
                    }

                    if (document.DataState == BASEBean.eDataState.DS_ADD)
                    {
                        document.DataState = BASEBean.eDataState.DS_EDIT;
                    }
                }
                catch (Exception e)
                {
                    if (hasLocalTransaction)
                    {
                        documentDAO.RollbackTransaction();
                        LogManager.Error(e);
                    }
                    else
                    {
                        throw;
                    }
                }
            }
        }