#include "dicsrv.h"

L_CHAR* UnsupportedUIDs[] =
{
   UID_PATIENT_ROOT_QUERY_GET,
   UID_STUDY_ROOT_QUERY_GET,
   UID_PATIENT_STUDY_QUERY_FIND,
   UID_PATIENT_STUDY_QUERY_MOVE,
   UID_PATIENT_STUDY_QUERY_GET,
   UID_MODALITY_WORKLIST_FIND,
   UID_MEDIA_STORAGE_DIRECTORY,
   UID_BASIC_STUDY_NOTIFICATION_CLASS,
   UID_STORAGE_COMMITMENT_PUSH_MODEL_CLASS,
   UID_STORAGE_COMMITMENT_PUSH_MODEL_INSTANCE,
   UID_STORAGE_COMMITMENT_PULL_MODEL_CLASS,
   UID_STORAGE_COMMITMENT_PULL_MODEL_INSTANCE,
   UID_DETACHED_PATIENT_CLASS,
   UID_DETACHED_PATIENT_META_CLASS,
   UID_DETACHED_VISIT_CLASS,
   UID_DETACHED_STUDY_CLASS,
   UID_STUDY_COMPONENT_CLASS,
   UID_MODALITY_PERFORMED_CLASS,
   UID_MODALITY_PERFORMED_RETRIEVE_CLASS,
   UID_MODALITY_PERFORMED_NOTIFICATION_CLASS,
   UID_DETACHED_RESULTS_CLASS,
   UID_DETACHED_RESULTS_META_CLASS,
   UID_DETACHED_STUDY_META_CLASS,
   UID_DETACHED_INTERPRETATION_CLASS,
   UID_BASIC_FILM_SESSION_CLASS,
   UID_BASIC_FILM_BOX_CLASS,
   UID_BASIC_GRAYSCALE_IMAGE_BOX_CLASS,
   UID_BASIC_COLOR_IMAGE_BOX_CLASS,
   UID_REFERENCED_IMAGE_BOX_CLASS_RETIRED,
   UID_BASIC_GRAYSCALE_PRINT_META_CLASS,
   UID_REFERENCED_GRAYSCALE_PRINT_META_CLASS_RETIRED,
   UID_PRINT_JOB_CLASS,
   UID_BASIC_ANNOTATION_BOX_CLASS,
   UID_PRINTER_CLASS,
   UID_PRINTER_INSTANCE,
   UID_BASIC_COLOR_PRINT_META_CLASS,
   UID_REFERENCED_COLOR_PRINT_META_CLASS_RETIRED,
   UID_VOI_LUT_BOX_CLASS_RETIRED,
   UID_PRESENTATION_LUT_CLASS,
   UID_IMAGE_OVERLAY_BOX_CLASS_RETIRED,
   UID_PRINT_QUEUE_INSTANCE,
   UID_PRINT_QUEUE_CLASS,
   UID_STORED_PRINT_STORAGE_CLASS,
   UID_HARDCOPY_GRAYSCALE_IMAGE_STORAGE_CLASS,
   UID_HARDCOPY_COLOR_IMAGE_STORAGE_CLASS,
   UID_PULL_PRINT_REQUEST_CLASS,
   UID_PULL_STORED_PRINT_META_CLASS,
   UID_GE_MR_IMAGE,
   UID_GE_CT_IMAGE,
   UID_GE_DISPLAY_IMAGERMATION,
   UID_GE_ARM_MIGRATION,
   UID_GE_ARM_MIGRATION_INSTANCE,

   UID_JPEG_EXTENDED_3_5,
   UID_JPEG_SPECTRAL_NONHIER_6_8,
   UID_JPEG_SPECTRAL_NONHIER_7_9,
   UID_JPEG_FULL_NONHIER_10_12,
   UID_JPEG_FULL_NONHIER_11_13,
   UID_JPEG_LOSSLESS_NONHIER_15,
   UID_JPEG_EXTENDED_HIER_16_18,
   UID_JPEG_EXTENDED_HIER_17_19,
   UID_JPEG_SPECTRAL_HIER_20_22,
   UID_JPEG_SPECTRAL_HIER_21_23,
   UID_JPEG_FULL_HIER_24_26,
   UID_JPEG_FULL_HIER_25_27,
   UID_JPEG_LOSSLESS_HIER_PROCESS_28,
   UID_JPEG_LOSSLESS_HIER_PROCESS_29,
   UID_JPEG_LS_LOSSLESS,
   UID_JPEG_LS_LOSSY
};

VOID RemoveUnsupportedUIDs()
{
   pDICOMUID pUID;
   int iSize, i;

   iSize = sizeof(UnsupportedUIDs) / sizeof(UnsupportedUIDs[0]);
   for (i = 0; i < iSize; i++)
   {
      pUID = L_DicomFindUID(UnsupportedUIDs[i]);
      if (pUID)
         L_DicomDeleteUID(pUID);
   }
}

VOID InitDialog(HWND hDlg)
{
   HBITMAP hBitmap;
   RECT rcCtl;
   RECT rcClient;
   LV_COLUMN lvcol;
   L_INT nRet;

   SendMessage(hDlg, WM_SETICON, ICON_BIG, (LPARAM) LoadIcon(ghInstance, MAKEINTRESOURCE(IDI_LEAD)));

   gbImport = FALSE;

   // Remove the Abstract and Transfer Syntaxes we don't support
   RemoveUnsupportedUIDs();

   memset(&gBitmap, 0, sizeof(BITMAPHANDLE));

   /* image list */
   ghImageList = ImageList_Create(16, 16, ILC_COLOR, 2, 2);
   
   hBitmap = LoadBitmap(ghInstance, MAKEINTRESOURCE(IDB_BITMAP3));
   ImageList_Add(ghImageList, hBitmap, NULL);
   DeleteObject(hBitmap);

   hBitmap = LoadBitmap(ghInstance, MAKEINTRESOURCE(IDB_BITMAP4));
   ImageList_Add(ghImageList, hBitmap, NULL);
   DeleteObject(hBitmap);

   hBitmap = LoadBitmap(ghInstance, MAKEINTRESOURCE(IDB_BITMAP5));
   ImageList_Add(ghImageList, hBitmap, NULL);
   DeleteObject(hBitmap);

   TreeView_SetImageList(GetDlgItem(hDlg, IDC_TREE3), ghImageList, TVSIL_NORMAL);

   GetClientRect(hDlg, &rcClient);
   GetWindowRect(GetDlgItem(hDlg, IDC_TREE1), &rcCtl);
	ScreenToClient(hDlg, (LPPOINT)&rcCtl);
	ScreenToClient(hDlg, ((LPPOINT)&rcCtl)+1);
   SetWindowPos(GetDlgItem(hDlg, IDC_TREE1), NULL, 0, 0, RECTWIDTH(&rcCtl), RECTHEIGHT(&rcClient)-rcCtl.top, SWP_NOMOVE);

   GetWindowRect(GetDlgItem(hDlg, IDC_TREE2), &rcCtl);
	ScreenToClient(hDlg, (LPPOINT)&rcCtl);
	ScreenToClient(hDlg, ((LPPOINT)&rcCtl)+1);
   SetWindowPos(GetDlgItem(hDlg, IDC_TREE2), NULL, 0, 0, RECTWIDTH(&rcCtl), RECTHEIGHT(&rcClient)-rcCtl.top, SWP_NOMOVE);

   SetWindowPos(GetDlgItem(hDlg, IDC_LEAD1), NULL, 0, 0, RECTWIDTH(&rcCtl), RECTHEIGHT(&rcClient)-rcCtl.top, SWP_NOMOVE);
   ShowWindow(GetDlgItem(hDlg, IDC_LEAD1), SW_HIDE);

   ShowWindow(GetDlgItem(hDlg, IDC_BUTTON4), SW_HIDE);

   GetWindowRect(GetDlgItem(hDlg, IDC_TREE3), &rcCtl);
	ScreenToClient(hDlg, (LPPOINT)&rcCtl);
	ScreenToClient(hDlg, ((LPPOINT)&rcCtl)+1);
   SetWindowPos(GetDlgItem(hDlg, IDC_TREE3), NULL, 0, 0, RECTWIDTH(&rcCtl), RECTHEIGHT(&rcClient)-rcCtl.top, SWP_NOMOVE);
   ShowWindow(GetDlgItem(hDlg, IDC_TREE3), SW_HIDE);

   lvcol.fmt      = LVCFMT_LEFT;
   lvcol.cx       = 100; 
   lvcol.mask     = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH;
   lvcol.pszText  = "User";
   ListView_InsertColumn(GetDlgItem(hDlg, IDC_LIST1), 0, &lvcol);
   lvcol.mask     = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
   lvcol.pszText  = "IP";
   lvcol.iSubItem = 1; 
   ListView_InsertColumn(GetDlgItem(hDlg, IDC_LIST1), 1, &lvcol);
   lvcol.mask     = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
   lvcol.pszText  = "Port";
   lvcol.iSubItem = 2; 
   ListView_InsertColumn(GetDlgItem(hDlg, IDC_LIST1), 2, &lvcol);
   lvcol.mask     = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
   lvcol.pszText  = "Timeout";
   lvcol.iSubItem = 3; 
   ListView_InsertColumn(GetDlgItem(hDlg, IDC_LIST1), 3, &lvcol);
   LoadClientsList(hDlg);

   lvcol.fmt      = LVCFMT_LEFT; 
   lvcol.cx       = 100; 
   lvcol.mask     = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH;
   lvcol.pszText  = "Date";
   ListView_InsertColumn(GetDlgItem(hDlg, IDC_LIST2), 0, &lvcol);
   lvcol.mask     = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
   lvcol.pszText  = "User";
   lvcol.iSubItem = 1; 
   ListView_InsertColumn(GetDlgItem(hDlg, IDC_LIST2), 1, &lvcol);
   lvcol.mask     = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
   lvcol.pszText  = "Event";
   lvcol.iSubItem = 2; 
   ListView_InsertColumn(GetDlgItem(hDlg, IDC_LIST2), 2, &lvcol);
   LoadEventsLog(hDlg);

   gpDisplay = NULL;

   ghServerDS = L_DicomCreateDS(gszTempFilesFolder);
   if (!ghServerDS)
   {
      MessageBox(hDlg, "Error starting server!", "Error", MB_OK);
      EndDialog(hDlg, IDCANCEL);
      return;
   }

   // Build DICOM Directory from the database
   InitServerDS(hDlg);
   
   //display the data set
   DisplayDICOMDir(hDlg);
   
   //init server
   nRet = L_DicomStartUp();
   if(nRet != DICOM_SUCCESS)
   {
      MessageBox(hDlg, "Error starting server!", "Error", MB_OK);
      EndDialog(hDlg, IDCANCEL);
      return;
   }

   ghServer = L_DicomCreateNet(gszTempFilesFolder, DICOM_SECURE_NONE);
   if(!ghServer)
   {
      MessageBox(hDlg, "Error starting server!", "Error", MB_OK);
      EndDialog(hDlg, IDCANCEL);
      return;
   }
   SetServerCallbacks(hDlg);

   ghClient = L_DicomCreateNet(gszTempFilesFolder, DICOM_SECURE_NONE);
   if(!ghClient)
   {
      MessageBox(hDlg, "Error starting server!", "Error", MB_OK);
      EndDialog(hDlg, IDCANCEL);
      return;
   }
   SetClientCallbacks(hDlg, ghClient);

   ghMovePDU = L_DicomCreateAssociate(TRUE);

   nRet = L_DicomListen(ghServer, "", guServerPort, giMaxClients);
   if(nRet != DICOM_SUCCESS)
   {
      MessageBox(hDlg, "Error starting server!", "Error", MB_OK);
      EndDialog(hDlg, IDCANCEL);
      return;
   }
   LogEvent(hDlg, gszServerAETitle, "Server StartUp");
}

// If successful, freeing the allocated memory is the responsibility of the caller.
BOOL LoadSetting(HANDLE hFile, LPSTR* ppszSetting)
{
   DWORD dwBytesRead;
   UINT uLength;
   LPSTR pszSetting;

   if (!ReadFile(hFile, &uLength, sizeof(uLength), &dwBytesRead, NULL))
   {
      CloseHandle(hFile);
      return FALSE;
   }
   if (dwBytesRead != sizeof(uLength))
   {
      CloseHandle(hFile);
      return FALSE;
   }

   pszSetting = (LPSTR) malloc(uLength + 1);
   if (!pszSetting)
   {
      CloseHandle(hFile);
      return FALSE;
   }

   if (!ReadFile(hFile, pszSetting , uLength, &dwBytesRead, NULL))
   {
      CloseHandle(hFile);
      free(pszSetting);
      return FALSE;
   }
   if (dwBytesRead != uLength)
   {
      CloseHandle(hFile);
      free(pszSetting);
      return FALSE;
   }

   pszSetting[uLength] = '\0';
   *ppszSetting = pszSetting;

   return TRUE;
}

BOOL LoadServerSettings()
{
   HANDLE hFile;
   char szFilename[MAX_PATH];
   LPSTR pszSetting;

   lstrcpy(szFilename, gszApplicationFolder);
   lstrcat(szFilename, SERVER_SETTINGS_FILENAME);

   hFile = CreateFile(szFilename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
   if (hFile == INVALID_HANDLE_VALUE)
   {
      return FALSE;
   }

   if (!LoadSetting(hFile, &pszSetting))
   {
      return FALSE;
   }
   lstrcpyn(gszConnectionString, pszSetting, sizeof(gszConnectionString) / sizeof(gszConnectionString[0]));
   free(pszSetting);

   if (!LoadSetting(hFile, &pszSetting))
   {
      return FALSE;
   }
   lstrcpyn(gszImagesFolder, pszSetting, sizeof(gszImagesFolder) / sizeof(gszImagesFolder[0]));
   free(pszSetting);

   if (!LoadSetting(hFile, &pszSetting))
   {
      return FALSE;
   }
   lstrcpyn(gszTempFilesFolder, pszSetting, sizeof(gszTempFilesFolder) / sizeof(gszTempFilesFolder[0]));
   free(pszSetting);

   if (!LoadSetting(hFile, &pszSetting))
   {
      return FALSE;
   }
   lstrcpyn(gszServerAETitle, pszSetting, sizeof(gszServerAETitle) / sizeof(gszServerAETitle[0]));
   free(pszSetting);

   if (!LoadSetting(hFile, &pszSetting))
   {
      return FALSE;
   }
   guServerPort = atoi(pszSetting);
   free(pszSetting);

   if (!LoadSetting(hFile, &pszSetting))
   {
      return FALSE;
   }
   giTimeOut = atoi(pszSetting);
   free(pszSetting);

   if (!LoadSetting(hFile, &pszSetting))
   {
      return FALSE;
   }
   giMaxClients = atoi(pszSetting);
   free(pszSetting);

   if (!LoadSetting(hFile, &pszSetting))
   {
      return FALSE;
   }
   gbGenerateEventsLogFile = atoi(pszSetting);
   free(pszSetting);

   if (!LoadSetting(hFile, &pszSetting))
   {
      return FALSE;
   }
   gbSaveReceivedCSs = atoi(pszSetting);
   free(pszSetting);

   if (!LoadSetting(hFile, &pszSetting))
   {
      return FALSE;
   }
   gbSaveReceivedDSs = atoi(pszSetting);
   free(pszSetting);

   if (!LoadSetting(hFile, &pszSetting))
   {
      return FALSE;
   }
   gbSaveSentDSs = atoi(pszSetting);
   free(pszSetting);

   if (!LoadSetting(hFile, &pszSetting))
   {
      return FALSE;
   }
   lstrcpyn(gszLogFolder, pszSetting, sizeof(gszLogFolder) / sizeof(gszLogFolder[0]));
   free(pszSetting);

   CloseHandle(hFile);

   return TRUE;
}

VOID LoadClientsList(HWND hDlg)
{
   char szBuffer[128];
   char szFile[MAX_PATH];
   FILE* pFile;

   char szAETitle[20];
   char szIPAddress[32];
   char szPortNumber[8];
   char szTimeout[16];

   char* pFind, * pStr;

   LV_ITEM lvi;
   int iPos;
   
   ListView_DeleteAllItems(GetDlgItem(hDlg, IDC_LIST1));

   wsprintf(szFile, TEXT("%s%s"), gszApplicationFolder, CLIENTS_LIST_FILENAME);
   if ((pFile = fopen(szFile, "r")) != NULL)
   {
      while (fgets(szBuffer, sizeof(szBuffer), pFile))
      {
         lstrcpy(szAETitle, "");
         lstrcpy(szIPAddress, "");
         lstrcpy(szPortNumber, "0");
         lstrcpy(szTimeout, "0");

         pStr = szBuffer;

         pFind = strchr(pStr, ',');
         if (pFind)
         {
            *pFind = '\0';
            lstrcpyn(szAETitle, pStr, sizeof(szAETitle) / sizeof(szAETitle[0]));
            pStr = pFind + 1;
         }

         pFind = strchr(pStr, ',');
         if (pFind)
         {
            *pFind = '\0';
            lstrcpyn(szIPAddress, pStr, sizeof(szIPAddress) / sizeof(szIPAddress[0]));
            pStr = pFind + 1;
         }

         pFind = strchr(pStr, ',');
         if (pFind)
         {
            *pFind = '\0';
            lstrcpyn(szPortNumber, pStr, sizeof(szPortNumber) / sizeof(szPortNumber[0]));
            pStr = pFind + 1;
         }

         pFind = strchr(pStr, '\n');
         if (pFind)
         {
            *pFind = '\0';
            lstrcpyn(szTimeout, pStr, sizeof(szTimeout) / sizeof(szTimeout[0]));
         }

         memset(&lvi, 0, sizeof(LV_ITEM));
         lvi.mask     = LVIF_TEXT;
         lvi.iItem    = ListView_GetItemCount(GetDlgItem(hDlg, IDC_LIST1));
         lvi.pszText  = szAETitle;
         iPos = ListView_InsertItem(GetDlgItem(hDlg, IDC_LIST1), &lvi);
         if (iPos != -1)
         {
            lvi.mask  = LVIF_TEXT;
            lvi.iItem = iPos;

            lvi.iSubItem = 1;
            lvi.pszText  = szIPAddress;
            ListView_SetItem(GetDlgItem(hDlg, IDC_LIST1), &lvi);

            lvi.iSubItem = 2;
            lvi.pszText  = szPortNumber;
            ListView_SetItem(GetDlgItem(hDlg, IDC_LIST1), &lvi);

            lvi.iSubItem = 3;
            lvi.pszText  = szTimeout;
            ListView_SetItem(GetDlgItem(hDlg, IDC_LIST1), &lvi);
         }
      }

      fclose(pFile);
   }
}

VOID LoadEventsLog(HWND hDlg)
{
   char szBuffer[512];
   char szFile[MAX_PATH];
   FILE* pFile;

   char szDate[80];
   char szClient[20];
   char szEventDesc[256];

   char* pFind, * pStr;
   
   LV_ITEM lvi;
   int iPos;
   
   ListView_DeleteAllItems(GetDlgItem(hDlg, IDC_LIST2));

   wsprintf(szFile, TEXT("%s%s"), gszApplicationFolder, EVENTS_LOG_FILENAME);
   if ((pFile = fopen(szFile, "r")) != NULL)
   {
      while (fgets(szBuffer, sizeof(szBuffer), pFile))
      {
         lstrcpy(szDate, "");
         lstrcpy(szClient, "");
         lstrcpy(szEventDesc, "");

         pStr = szBuffer;

         pFind = strchr(pStr, ',');
         if (pFind)
         {
            *pFind = '\0';
            lstrcpyn(szDate, pStr, sizeof(szDate) / sizeof(szDate[0]));
            pStr = pFind + 1;
         }

         pFind = strchr(pStr, ',');
         if (pFind)
         {
            *pFind = '\0';
            lstrcpyn(szClient, pStr, sizeof(szClient) / sizeof(szClient[0]));
            pStr = pFind + 1;
         }

         pFind = strchr(pStr, '\n');
         if (pFind)
         {
            *pFind = '\0';
            lstrcpyn(szEventDesc, pStr, sizeof(szEventDesc) / sizeof(szEventDesc[0]));
         }

         memset(&lvi, 0, sizeof(LV_ITEM));
         lvi.mask     = LVIF_TEXT;
         lvi.iItem    = ListView_GetItemCount(GetDlgItem(hDlg, IDC_LIST2));
         lvi.pszText  = szDate;
         iPos = ListView_InsertItem(GetDlgItem(hDlg, IDC_LIST2), &lvi);
         if (iPos != -1)
         {
            lvi.mask     = LVIF_TEXT;
            lvi.iItem    = iPos;

            lvi.iSubItem = 1;
            lvi.pszText  = szClient;
            ListView_SetItem(GetDlgItem(hDlg, IDC_LIST2), &lvi);

            lvi.iSubItem = 2;
            lvi.pszText  = szEventDesc;
            ListView_SetItem(GetDlgItem(hDlg, IDC_LIST2), &lvi);
         }
      }

      fclose(pFile);
   }
}

VOID DeleteDRElement(pDICOMELEMENT pDR, L_UINT32 uTag)
{
   pDICOMELEMENT pElement;

   if (!pDR)
      return;

   pElement = L_DicomGetChildElement(ghServerDS, pDR, TRUE);
   if (pElement)
   {
      pElement = L_DicomFindFirstElement(ghServerDS, pElement, uTag, TRUE);
      if (pElement)
         L_DicomDeleteElement(ghServerDS, pElement);
   }   
}

VOID InitServerDS(HWND hDlg)
{
   DBHANDLES db;
   PATIENTSRECORDSET PatientsRS;
   STUDIESRECORDSET StudiesRS;
   SERIESRECORDSET SeriesRS;
   IMAGESRECORDSET ImagesRS;
   char szQueryString[1024];
   
   pDICOMELEMENT pPatientDR, pStudyDR, pSeriesDR, pImageDR, pElement;
   char szValue[64];

   L_DicomResetDS(ghServerDS);
   L_DicomInitDS(ghServerDS, CLASS_BASIC_DIRECTORY, DS_LITTLE_ENDIAN | DS_EXPLICIT_VR);

   if (!OpenDatabaseConnection(&db))
   {
      MessageBox(hDlg, "Database error.", "Error", MB_OK | MB_ICONERROR);
      return;
   }

   if (!OpenPatientsRecordset(db.hDbc, &PatientsRS, "SELECT * FROM Patients", TRUE))
   {
      CloseDatabaseConnection(&db);
      MessageBox(hDlg, "Database error.", "Error", MB_OK | MB_ICONERROR);
      return;
   }
   while (!PatientsRS.bEOF)
   {
      // Insert a Patient Directory Record
      pPatientDR = L_DicomInsertKey(ghServerDS, NULL, "PATIENT", FALSE);
      DeleteDRElement(pPatientDR, TAG_PRIVATE_RECORD_UID);
      DeleteDRElement(pPatientDR, TAG_REFERENCED_FILE_ID);
      DeleteDRElement(pPatientDR, TAG_REFERENCED_SOP_CLASS_UID_IN_FILE);
      DeleteDRElement(pPatientDR, TAG_REFERENCED_SOP_INSTANCE_UID_IN_FILE);
      DeleteDRElement(pPatientDR, TAG_REFERENCED_TRANSFER_SYNTAX_UID_IN_FILE);
      DeleteDRElement(pPatientDR, TAG_RECORD_IN_USE_FLAG);

      pElement = L_DicomGetChildElement(ghServerDS, pPatientDR, TRUE);

      // Set the Selection Keys of the Patient DR

      // Patient ID
      SetElement(ghServerDS, pElement, TAG_PATIENT_ID, VR_LO, PatientsRS.szPatientID);

      // Patient Name
      if (PatientsRS.lPatientNameLenOrInd == SQL_NULL_DATA)
      {
         SetElement(ghServerDS, pElement, TAG_PATIENT_NAME, VR_PN, NULL);
      }
      else
      {
         SetElement(ghServerDS, pElement, TAG_PATIENT_NAME, VR_PN, PatientsRS.szPatientName);
      }      

      // Patient Birth Date
      if (PatientsRS.lPatientBirthDateInd != SQL_NULL_DATA)
         SetDateTimeElement(ghServerDS, pElement, &PatientsRS.PatientBirthDate,
                            TAG_PATIENT_BIRTH_DATE, TRUE);

      // Patient Birth Time
      if (PatientsRS.lPatientBirthTimeInd != SQL_NULL_DATA)
         SetDateTimeElement(ghServerDS, pElement, &PatientsRS.PatientBirthTime,
                            TAG_PATIENT_BIRTH_TIME, FALSE);

      // Patient Sex
      if (PatientsRS.lPatientSexLenOrInd != SQL_NULL_DATA)
         SetElement(ghServerDS, pElement, TAG_PATIENT_SEX, VR_CS, PatientsRS.szPatientSex);

      // Ethnic Group
      if (PatientsRS.lEthnicGroupLenOrInd != SQL_NULL_DATA)
         SetElement(ghServerDS, pElement, TAG_ETHNIC_GROUP, VR_SH, PatientsRS.szEthnicGroup);

      // Patient Comments
      if (PatientsRS.lPatientCommentsLenOrInd != SQL_NULL_DATA)
         SetElement(ghServerDS, pElement, TAG_PATIENT_COMMENTS, VR_LT, PatientsRS.szPatientComments);


      wsprintf(szQueryString,
               "SELECT * FROM Studies WHERE PatientID = '%s'", PatientsRS.szPatientID);
      if (!OpenStudiesRecordset(db.hDbc, &StudiesRS, szQueryString, TRUE))
      {
         WrapUpDatabase(&db, &PatientsRS, NULL, NULL, NULL);
         MessageBox(hDlg, "Database error.", "Error", MB_OK | MB_ICONERROR);
         return;
      }
      while (!StudiesRS.bEOF)
      {
         // Insert a Study Directory Record
         pStudyDR = L_DicomInsertKey(ghServerDS, pPatientDR, "STUDY", FALSE);
         DeleteDRElement(pStudyDR, TAG_PRIVATE_RECORD_UID);
         DeleteDRElement(pStudyDR, TAG_REFERENCED_FILE_ID);
         DeleteDRElement(pStudyDR, TAG_REFERENCED_SOP_CLASS_UID_IN_FILE);
         DeleteDRElement(pStudyDR, TAG_REFERENCED_SOP_INSTANCE_UID_IN_FILE);
         DeleteDRElement(pStudyDR, TAG_REFERENCED_TRANSFER_SYNTAX_UID_IN_FILE);
         DeleteDRElement(pStudyDR, TAG_RECORD_IN_USE_FLAG);

         pElement = L_DicomGetChildElement(ghServerDS, pStudyDR, TRUE);

         // Set the Selection Keys of the Study DR

         // Study Instance UID
         SetElement(ghServerDS, pElement, TAG_STUDY_INSTANCE_UID, VR_UI, StudiesRS.szStudyInstanceUID);

         // Study Date
         if (StudiesRS.lStudyDateInd == SQL_NULL_DATA)
         {
            SetDateTimeElement(ghServerDS, pElement, NULL, TAG_STUDY_DATE, TRUE);
         }
         else
         {
            SetDateTimeElement(ghServerDS, pElement, &StudiesRS.StudyDate, TAG_STUDY_DATE, TRUE);
         }

         // Study Time
         if (StudiesRS.lStudyTimeInd == SQL_NULL_DATA)
         {
            SetDateTimeElement(ghServerDS, pElement, NULL, TAG_STUDY_TIME, FALSE);
         }
         else
         {
            SetDateTimeElement(ghServerDS, pElement, &StudiesRS.StudyTime, TAG_STUDY_TIME, FALSE);
         }

         // Accession Number
         if (StudiesRS.lAccessionNumberLenOrInd == SQL_NULL_DATA)
         {
            SetElement(ghServerDS, pElement, TAG_ACCESSION_NUMBER, VR_SH, NULL);
         }
         else
         {
            SetElement(ghServerDS, pElement, TAG_ACCESSION_NUMBER, VR_SH, StudiesRS.szAccessionNumber);
         }

         // Study ID
         if (StudiesRS.lStudyIDLenOrInd == SQL_NULL_DATA)
         {
            SetElement(ghServerDS, pElement, TAG_STUDY_ID, VR_SH, NULL);
         }
         else
         {
            SetElement(ghServerDS, pElement, TAG_STUDY_ID, VR_SH, StudiesRS.szStudyID);
         }

         // Patient Name
         if (StudiesRS.lPatientNameLenOrInd != SQL_NULL_DATA)
            SetElement(ghServerDS, pElement, TAG_PATIENT_NAME, VR_PN, StudiesRS.szPatientName);

         // Patient ID
         if (StudiesRS.lPatientIDLenOrInd != SQL_NULL_DATA)
            SetElement(ghServerDS, pElement, TAG_PATIENT_ID, VR_LO, StudiesRS.szPatientID);

         // Study Description
         if (StudiesRS.lStudyDescriptionLenOrInd == SQL_NULL_DATA)
         {
            SetElement(ghServerDS, pElement, TAG_STUDY_DESCRIPTION, VR_LO, NULL);
         }
         else
         {
            SetElement(ghServerDS, pElement, TAG_STUDY_DESCRIPTION, VR_LO, StudiesRS.szStudyDescription);
         }

         wsprintf(szQueryString,
                  "SELECT * FROM Series WHERE StudyInstanceUID = '%s'", StudiesRS.szStudyInstanceUID);
         if (!OpenSeriesRecordset(db.hDbc, &SeriesRS, szQueryString, TRUE))
         {
            WrapUpDatabase(&db, &StudiesRS, &PatientsRS, NULL, NULL);
            MessageBox(hDlg, "Database error.", "Error", MB_OK | MB_ICONERROR);
            return;
         }
         while (!SeriesRS.bEOF)
         {
            // Insert a Series Directory Record
            pSeriesDR = L_DicomInsertKey(ghServerDS, pStudyDR, "SERIES", FALSE);
            DeleteDRElement(pSeriesDR, TAG_PRIVATE_RECORD_UID);
            DeleteDRElement(pSeriesDR, TAG_REFERENCED_FILE_ID);
            DeleteDRElement(pSeriesDR, TAG_REFERENCED_SOP_CLASS_UID_IN_FILE);
            DeleteDRElement(pSeriesDR, TAG_REFERENCED_SOP_INSTANCE_UID_IN_FILE);
            DeleteDRElement(pSeriesDR, TAG_REFERENCED_TRANSFER_SYNTAX_UID_IN_FILE);
            DeleteDRElement(pSeriesDR, TAG_RECORD_IN_USE_FLAG);

            pElement = L_DicomGetChildElement(ghServerDS, pSeriesDR, TRUE);

            // Set the Selection Keys of the Series DR

            // Series Instance UID
            SetElement(ghServerDS, pElement, TAG_SERIES_INSTANCE_UID, VR_UI, SeriesRS.szSeriesInstanceUID);

            // Modality
            if (SeriesRS.lModalityLenOrInd == SQL_NULL_DATA)
            {
               SetElement(ghServerDS, pElement, TAG_MODALITY, VR_CS, NULL);
            }
            else
            {
               SetElement(ghServerDS, pElement, TAG_MODALITY, VR_CS, SeriesRS.szModality);
            }

            // Series Number
            if (SeriesRS.lSeriesNumberInd == SQL_NULL_DATA)
            {
               SetElement(ghServerDS, pElement, TAG_SERIES_NUMBER, VR_IS, NULL);
            }
            else
            {
               SetElement(ghServerDS, pElement, TAG_SERIES_NUMBER, VR_IS,
                          ltoa(SeriesRS.lSeriesNumber, szValue, 10));
            }

            wsprintf(szQueryString,
                     "SELECT * FROM Images WHERE StudyInstanceUID = '%s' AND SeriesInstanceUID = '%s'",
                     SeriesRS.szStudyInstanceUID, SeriesRS.szSeriesInstanceUID);
            if (!OpenImagesRecordset(db.hDbc, &ImagesRS, szQueryString, TRUE))
            {
               WrapUpDatabase(&db, &SeriesRS, &StudiesRS, &PatientsRS, NULL);
               MessageBox(hDlg, "Database error.", "Error", MB_OK | MB_ICONERROR);
               return;
            }
            while (!ImagesRS.bEOF)
            {
               // Insert an Image Directory Record
               pImageDR = L_DicomInsertKey(ghServerDS, pSeriesDR, "IMAGE", FALSE);
               DeleteDRElement(pImageDR, TAG_PRIVATE_RECORD_UID);
               DeleteDRElement(pImageDR, TAG_RECORD_IN_USE_FLAG);

               pElement = L_DicomGetChildElement(ghServerDS, pImageDR, TRUE);

               // Referenced SOP Instance UID in File
               SetElement(ghServerDS, pElement, TAG_REFERENCED_SOP_INSTANCE_UID_IN_FILE, VR_UI, ImagesRS.szSOPInstanceUID);

               // Referenced SOP Class UID in File
               SetElement(ghServerDS, pElement, TAG_REFERENCED_SOP_CLASS_UID_IN_FILE, VR_UI, ImagesRS.szSOPClassUID);

               // Referenced Transfer Syntax UID in File
               SetElement(ghServerDS, pElement, TAG_REFERENCED_TRANSFER_SYNTAX_UID_IN_FILE, VR_UI, ImagesRS.szTransferSyntaxUID);

               // Referenced File ID
               if (ImagesRS.lReferencedFileLenOrInd != SQL_NULL_DATA)
                  SetElement(ghServerDS, pElement, TAG_REFERENCED_FILE_ID, VR_CS, ImagesRS.szReferencedFile);

               // Set the Selection Keys of the Image DR

               // Instance Number
               if (ImagesRS.lInstanceNumberInd == SQL_NULL_DATA)
               {
                  SetElement(ghServerDS, pElement, TAG_INSTANCE_NUMBER, VR_IS, NULL);
               }
               else
               {
                  SetElement(ghServerDS, pElement, TAG_INSTANCE_NUMBER, VR_IS,
                             ltoa(ImagesRS.lInstanceNumber, szValue, 10));
               }

               if (!GetNextRecord(&ImagesRS))
               {
                  WrapUpDatabase(&db, &ImagesRS, &SeriesRS, &StudiesRS, &PatientsRS);
                  MessageBox(hDlg, "Database error.", "Error", MB_OK | MB_ICONERROR);
                  return;
               }
            }
            CloseRecordset(&ImagesRS);

            if (!GetNextRecord(&SeriesRS))
            {
               WrapUpDatabase(&db, &SeriesRS, &StudiesRS, &PatientsRS, NULL);
               MessageBox(hDlg, "Database error.", "Error", MB_OK | MB_ICONERROR);
               return;
            }
         }
         CloseRecordset(&SeriesRS);

         if (!GetNextRecord(&StudiesRS))
         {
            WrapUpDatabase(&db, &StudiesRS, &PatientsRS, NULL, NULL);
            MessageBox(hDlg, "Database error.", "Error", MB_OK | MB_ICONERROR);
            return;
         }
      }
      CloseRecordset(&StudiesRS);

      if (!GetNextRecord(&PatientsRS))
      {
         WrapUpDatabase(&db, &PatientsRS, NULL, NULL, NULL);
         MessageBox(hDlg, "Database error.", "Error", MB_OK | MB_ICONERROR);
         return;
      }
   }
   CloseRecordset(&PatientsRS);

   CloseDatabaseConnection(&db);
}