Example #1
0
        public IActionResult AddToList(int drugId)
        {
            try
            {
                int? userId = HttpContext.Session.GetInt32("userId");
                User user   = _context.Users.Where(u => u.Id == userId)
                              .Include(u => u.Applicant)
                              .Include(u => u.Manufacturer)
                              .FirstOrDefault();

                if (user != null && user.Manufacturer != null)
                {
                    ViewBag.User = user;
                    Drug drug = _context.Drugs.Where(d => d.Id == drugId).Include(d => d.DrugManufacturers).FirstOrDefault();
                    if (drug != null)
                    {
                        DrugManufacturer dm = new DrugManufacturer
                        {
                            DrugId         = drug.Id,
                            Drug           = drug,
                            ManufacturerId = user.Manufacturer.Id,
                            Manufacturer   = user.Manufacturer
                        };
                        drug.DrugManufacturers.Add(dm);
                        _context.SaveChanges();
                    }
                    return(RedirectToAction("All", "Drug"));
                }
            }
            catch { }
            return(RedirectToAction("Login", "User"));
        }
        ///<summary>Inserts one DrugManufacturer into the database.  Provides option to use the existing priKey.  Doesn't use the cache.</summary>
        public static long InsertNoCache(DrugManufacturer drugManufacturer, bool useExistingPK)
        {
            bool   isRandomKeys = Prefs.GetBoolNoCache(PrefName.RandomPrimaryKeys);
            string command      = "INSERT INTO drugmanufacturer (";

            if (!useExistingPK && isRandomKeys)
            {
                drugManufacturer.DrugManufacturerNum = ReplicationServers.GetKeyNoCache("drugmanufacturer", "DrugManufacturerNum");
            }
            if (isRandomKeys || useExistingPK)
            {
                command += "DrugManufacturerNum,";
            }
            command += "ManufacturerName,ManufacturerCode) VALUES(";
            if (isRandomKeys || useExistingPK)
            {
                command += POut.Long(drugManufacturer.DrugManufacturerNum) + ",";
            }
            command +=
                "'" + POut.String(drugManufacturer.ManufacturerName) + "',"
                + "'" + POut.String(drugManufacturer.ManufacturerCode) + "')";
            if (useExistingPK || isRandomKeys)
            {
                Db.NonQ(command);
            }
            else
            {
                drugManufacturer.DrugManufacturerNum = Db.NonQ(command, true, "DrugManufacturerNum", "drugManufacturer");
            }
            return(drugManufacturer.DrugManufacturerNum);
        }
        ///<summary>Inserts one DrugManufacturer into the database.  Provides option to use the existing priKey.</summary>
        public static long Insert(DrugManufacturer drugManufacturer, bool useExistingPK)
        {
            if (!useExistingPK && PrefC.RandomKeys)
            {
                drugManufacturer.DrugManufacturerNum = ReplicationServers.GetKey("drugmanufacturer", "DrugManufacturerNum");
            }
            string command = "INSERT INTO drugmanufacturer (";

            if (useExistingPK || PrefC.RandomKeys)
            {
                command += "DrugManufacturerNum,";
            }
            command += "ManufacturerName,ManufacturerCode) VALUES(";
            if (useExistingPK || PrefC.RandomKeys)
            {
                command += POut.Long(drugManufacturer.DrugManufacturerNum) + ",";
            }
            command +=
                "'" + POut.String(drugManufacturer.ManufacturerName) + "',"
                + "'" + POut.String(drugManufacturer.ManufacturerCode) + "')";
            if (useExistingPK || PrefC.RandomKeys)
            {
                Db.NonQ(command);
            }
            else
            {
                drugManufacturer.DrugManufacturerNum = Db.NonQ(command, true, "DrugManufacturerNum", "drugManufacturer");
            }
            return(drugManufacturer.DrugManufacturerNum);
        }
Example #4
0
 ///<summary>Inserts one DrugManufacturer into the database.  Returns the new priKey.</summary>
 internal static long Insert(DrugManufacturer drugManufacturer)
 {
     if(DataConnection.DBtype==DatabaseType.Oracle) {
         drugManufacturer.DrugManufacturerNum=DbHelper.GetNextOracleKey("drugmanufacturer","DrugManufacturerNum");
         int loopcount=0;
         while(loopcount<100){
             try {
                 return Insert(drugManufacturer,true);
             }
             catch(Oracle.DataAccess.Client.OracleException ex){
                 if(ex.Number==1 && ex.Message.ToLower().Contains("unique constraint") && ex.Message.ToLower().Contains("violated")){
                     drugManufacturer.DrugManufacturerNum++;
                     loopcount++;
                 }
                 else{
                     throw ex;
                 }
             }
         }
         throw new ApplicationException("Insert failed.  Could not generate primary key.");
     }
     else {
         return Insert(drugManufacturer,false);
     }
 }
 ///<summary>Inserts one DrugManufacturer into the database.  Returns the new priKey.</summary>
 public static long Insert(DrugManufacturer drugManufacturer)
 {
     if (DataConnection.DBtype == DatabaseType.Oracle)
     {
         drugManufacturer.DrugManufacturerNum = DbHelper.GetNextOracleKey("drugmanufacturer", "DrugManufacturerNum");
         int loopcount = 0;
         while (loopcount < 100)
         {
             try {
                 return(Insert(drugManufacturer, true));
             }
             catch (Oracle.ManagedDataAccess.Client.OracleException ex) {
                 if (ex.Number == 1 && ex.Message.ToLower().Contains("unique constraint") && ex.Message.ToLower().Contains("violated"))
                 {
                     drugManufacturer.DrugManufacturerNum++;
                     loopcount++;
                 }
                 else
                 {
                     throw ex;
                 }
             }
         }
         throw new ApplicationException("Insert failed.  Could not generate primary key.");
     }
     else
     {
         return(Insert(drugManufacturer, false));
     }
 }
        ///<summary>Updates one DrugManufacturer in the database.  Uses an old object to compare to, and only alters changed fields.  This prevents collisions and concurrency problems in heavily used tables.  Returns true if an update occurred.</summary>
        public static bool Update(DrugManufacturer drugManufacturer, DrugManufacturer oldDrugManufacturer)
        {
            string command = "";

            if (drugManufacturer.ManufacturerName != oldDrugManufacturer.ManufacturerName)
            {
                if (command != "")
                {
                    command += ",";
                }
                command += "ManufacturerName = '" + POut.String(drugManufacturer.ManufacturerName) + "'";
            }
            if (drugManufacturer.ManufacturerCode != oldDrugManufacturer.ManufacturerCode)
            {
                if (command != "")
                {
                    command += ",";
                }
                command += "ManufacturerCode = '" + POut.String(drugManufacturer.ManufacturerCode) + "'";
            }
            if (command == "")
            {
                return(false);
            }
            command = "UPDATE drugmanufacturer SET " + command
                      + " WHERE DrugManufacturerNum = " + POut.Long(drugManufacturer.DrugManufacturerNum);
            Db.NonQ(command);
            return(true);
        }
Example #7
0
        private void RXA(VaccinePat vaccine)
        {
            VaccineDef vaccineDef = VaccineDefs.GetOne(vaccine.VaccineDefNum);

            seg = new SegmentHL7(SegmentName.RXA);
            seg.SetField(0, "RXA");
            seg.SetField(1, "0");           //fixed
            seg.SetField(2, "1");           //fixed
            seg.SetField(3, vaccine.DateTimeStart.ToString("yyyyMMddHHmm"));
            seg.SetField(4, vaccine.DateTimeEnd.ToString("yyyyMMddHHmm"));
            seg.SetField(5, vaccineDef.CVXCode, vaccineDef.VaccineName, "HL70292");
            if (vaccine.AdministeredAmt == 0)
            {
                seg.SetField(6, "999");
            }
            else
            {
                seg.SetField(6, vaccine.AdministeredAmt.ToString());
            }
            if (vaccine.DrugUnitNum != 0)
            {
                DrugUnit drugUnit = DrugUnits.GetOne(vaccine.DrugUnitNum);
                seg.SetField(7, drugUnit.UnitIdentifier, drugUnit.UnitText, "ISO+");
            }
            seg.SetField(15, vaccine.LotNumber);           //optional.
            //17-Manufacturer.  Is this really optional?
            if (vaccineDef.DrugManufacturerNum != 0)       //always?
            {
                DrugManufacturer manufacturer = DrugManufacturers.GetOne(vaccineDef.DrugManufacturerNum);
                seg.SetField(17, manufacturer.ManufacturerCode, manufacturer.ManufacturerName, "HL70227");
            }
            seg.SetField(21, "A");           //21-Action code, A=Add
            msg.Segments.Add(seg);
        }
        ///<summary>Updates one DrugManufacturer in the database.</summary>
        public static void Update(DrugManufacturer drugManufacturer)
        {
            string command = "UPDATE drugmanufacturer SET "
                             + "ManufacturerName   = '" + POut.String(drugManufacturer.ManufacturerName) + "', "
                             + "ManufacturerCode   = '" + POut.String(drugManufacturer.ManufacturerCode) + "' "
                             + "WHERE DrugManufacturerNum = " + POut.Long(drugManufacturer.DrugManufacturerNum);

            Db.NonQ(command);
        }
 ///<summary>Returns true if Update(DrugManufacturer,DrugManufacturer) would make changes to the database.
 ///Does not make any changes to the database and can be called before remoting role is checked.</summary>
 public static bool UpdateComparison(DrugManufacturer drugManufacturer, DrugManufacturer oldDrugManufacturer)
 {
     if (drugManufacturer.ManufacturerName != oldDrugManufacturer.ManufacturerName)
     {
         return(true);
     }
     if (drugManufacturer.ManufacturerCode != oldDrugManufacturer.ManufacturerCode)
     {
         return(true);
     }
     return(false);
 }
		///<summary>Converts a DataTable to a list of objects.</summary>
		public static List<DrugManufacturer> TableToList(DataTable table){
			List<DrugManufacturer> retVal=new List<DrugManufacturer>();
			DrugManufacturer drugManufacturer;
			for(int i=0;i<table.Rows.Count;i++) {
				drugManufacturer=new DrugManufacturer();
				drugManufacturer.DrugManufacturerNum= PIn.Long  (table.Rows[i]["DrugManufacturerNum"].ToString());
				drugManufacturer.ManufacturerName   = PIn.String(table.Rows[i]["ManufacturerName"].ToString());
				drugManufacturer.ManufacturerCode   = PIn.String(table.Rows[i]["ManufacturerCode"].ToString());
				retVal.Add(drugManufacturer);
			}
			return retVal;
		}
Example #11
0
        ///<summary>Converts a DataTable to a list of objects.</summary>
        internal static List <DrugManufacturer> TableToList(DataTable table)
        {
            List <DrugManufacturer> retVal = new List <DrugManufacturer>();
            DrugManufacturer        drugManufacturer;

            for (int i = 0; i < table.Rows.Count; i++)
            {
                drugManufacturer = new DrugManufacturer();
                drugManufacturer.DrugManufacturerNum = PIn.Long(table.Rows[i]["DrugManufacturerNum"].ToString());
                drugManufacturer.ManufacturerName    = PIn.String(table.Rows[i]["ManufacturerName"].ToString());
                drugManufacturer.ManufacturerCode    = PIn.String(table.Rows[i]["ManufacturerCode"].ToString());
                retVal.Add(drugManufacturer);
            }
            return(retVal);
        }
Example #12
0
        ///<summary>Converts a DataTable to a list of objects.</summary>
        public static List <DrugManufacturer> TableToList(DataTable table)
        {
            List <DrugManufacturer> retVal = new List <DrugManufacturer>();
            DrugManufacturer        drugManufacturer;

            foreach (DataRow row in table.Rows)
            {
                drugManufacturer = new DrugManufacturer();
                drugManufacturer.DrugManufacturerNum = PIn.Long(row["DrugManufacturerNum"].ToString());
                drugManufacturer.ManufacturerName    = PIn.String(row["ManufacturerName"].ToString());
                drugManufacturer.ManufacturerCode    = PIn.String(row["ManufacturerCode"].ToString());
                retVal.Add(drugManufacturer);
            }
            return(retVal);
        }
Example #13
0
 ///<summary>Inserts one DrugManufacturer into the database.  Returns the new priKey.  Doesn't use the cache.</summary>
 public static long InsertNoCache(DrugManufacturer drugManufacturer)
 {
     if (DataConnection.DBtype == DatabaseType.MySql)
     {
         return(InsertNoCache(drugManufacturer, false));
     }
     else
     {
         if (DataConnection.DBtype == DatabaseType.Oracle)
         {
             drugManufacturer.DrugManufacturerNum = DbHelper.GetNextOracleKey("drugmanufacturer", "DrugManufacturerNum");                  //Cacheless method
         }
         return(InsertNoCache(drugManufacturer, true));
     }
 }
		///<summary>Inserts one DrugManufacturer into the database.  Provides option to use the existing priKey.</summary>
		public static long Insert(DrugManufacturer drugManufacturer,bool useExistingPK){
			if(!useExistingPK && PrefC.RandomKeys) {
				drugManufacturer.DrugManufacturerNum=ReplicationServers.GetKey("drugmanufacturer","DrugManufacturerNum");
			}
			string command="INSERT INTO drugmanufacturer (";
			if(useExistingPK || PrefC.RandomKeys) {
				command+="DrugManufacturerNum,";
			}
			command+="ManufacturerName,ManufacturerCode) VALUES(";
			if(useExistingPK || PrefC.RandomKeys) {
				command+=POut.Long(drugManufacturer.DrugManufacturerNum)+",";
			}
			command+=
				 "'"+POut.String(drugManufacturer.ManufacturerName)+"',"
				+"'"+POut.String(drugManufacturer.ManufacturerCode)+"')";
			if(useExistingPK || PrefC.RandomKeys) {
				Db.NonQ(command);
			}
			else {
				drugManufacturer.DrugManufacturerNum=Db.NonQ(command,true);
			}
			return drugManufacturer.DrugManufacturerNum;
		}
Example #15
0
 ///<summary>Inserts one DrugManufacturer into the database.  Returns the new priKey.</summary>
 public static long Insert(DrugManufacturer drugManufacturer)
 {
     return(Insert(drugManufacturer, false));
 }
		///<summary>Updates one DrugManufacturer in the database.  Uses an old object to compare to, and only alters changed fields.  This prevents collisions and concurrency problems in heavily used tables.</summary>
		public static void Update(DrugManufacturer drugManufacturer,DrugManufacturer oldDrugManufacturer){
			string command="";
			if(drugManufacturer.ManufacturerName != oldDrugManufacturer.ManufacturerName) {
				if(command!=""){ command+=",";}
				command+="ManufacturerName = '"+POut.String(drugManufacturer.ManufacturerName)+"'";
			}
			if(drugManufacturer.ManufacturerCode != oldDrugManufacturer.ManufacturerCode) {
				if(command!=""){ command+=",";}
				command+="ManufacturerCode = '"+POut.String(drugManufacturer.ManufacturerCode)+"'";
			}
			if(command==""){
				return;
			}
			command="UPDATE drugmanufacturer SET "+command
				+" WHERE DrugManufacturerNum = "+POut.Long(drugManufacturer.DrugManufacturerNum);
			Db.NonQ(command);
		}
		///<summary>Updates one DrugManufacturer in the database.</summary>
		public static void Update(DrugManufacturer drugManufacturer){
			string command="UPDATE drugmanufacturer SET "
				+"ManufacturerName   = '"+POut.String(drugManufacturer.ManufacturerName)+"', "
				+"ManufacturerCode   = '"+POut.String(drugManufacturer.ManufacturerCode)+"' "
				+"WHERE DrugManufacturerNum = "+POut.Long(drugManufacturer.DrugManufacturerNum);
			Db.NonQ(command);
		}
Example #18
0
        private void FormVaccinePatEdit_Load(object sender, EventArgs e)
        {
            Patient pat = Patients.GetLim(VaccinePatCur.PatNum);

            if (pat.Age != 0 && pat.Age < 3)
            {
                labelDocument.Text = "Document reason not given below.  Reason can include a contraindication due to a specific allergy, adverse effect, intollerance, or specific disease.";              //less leeway with reasons for kids.
            }
            _listVaccineDefs = VaccineDefs.GetDeepCopy();
            comboVaccine.Items.Clear();
            for (int i = 0; i < _listVaccineDefs.Count; i++)
            {
                comboVaccine.Items.Add(_listVaccineDefs[i].CVXCode + " - " + _listVaccineDefs[i].VaccineName);
                if (_listVaccineDefs[i].VaccineDefNum == VaccinePatCur.VaccineDefNum)
                {
                    comboVaccine.SelectedIndex = i;
                }
            }
            if (!IsNew && VaccinePatCur.VaccineDefNum != 0)
            {
                VaccineDef       vaccineDef   = VaccineDefs.GetOne(VaccinePatCur.VaccineDefNum);      //Need vaccine to get manufacturer.
                DrugManufacturer manufacturer = DrugManufacturers.GetOne(vaccineDef.DrugManufacturerNum);
                textManufacturer.Text = manufacturer.ManufacturerCode + " - " + manufacturer.ManufacturerName;
            }
            if (VaccinePatCur.DateTimeStart.Year > 1880)
            {
                textDateTimeStart.Text = VaccinePatCur.DateTimeStart.ToString();
            }
            if (VaccinePatCur.DateTimeEnd.Year > 1880)
            {
                textDateTimeStop.Text = VaccinePatCur.DateTimeEnd.ToString();
            }
            if (VaccinePatCur.AdministeredAmt != 0)
            {
                textAmount.Text = VaccinePatCur.AdministeredAmt.ToString();
            }
            _listDrugUnits = DrugUnits.GetDeepCopy();
            comboUnits.Items.Clear();
            comboUnits.Items.Add("none");
            comboUnits.SelectedIndex = 0;
            for (int i = 0; i < _listDrugUnits.Count; i++)
            {
                comboUnits.Items.Add(_listDrugUnits[i].UnitIdentifier);
                if (_listDrugUnits[i].DrugUnitNum == VaccinePatCur.DrugUnitNum)
                {
                    comboUnits.SelectedIndex = i + 1;
                }
            }
            textLotNum.Text = VaccinePatCur.LotNumber;
            if (VaccinePatCur.DateExpire.Year > 1880)
            {
                textDateExpiration.Text = VaccinePatCur.DateExpire.ToShortDateString();
            }
            listRefusalReason.Items.Clear();
            string[] arrayVaccineRefusalReasons = Enum.GetNames(typeof(VaccineRefusalReason));
            for (int i = 0; i < arrayVaccineRefusalReasons.Length; i++)
            {
                listRefusalReason.Items.Add(arrayVaccineRefusalReasons[i]);
                VaccineRefusalReason refusalReason = (VaccineRefusalReason)i;
                if (refusalReason == VaccinePatCur.RefusalReason)
                {
                    listRefusalReason.SelectedIndex = i;
                }
            }
            listCompletionStatus.Items.Clear();
            string[] arrayCompletionStatuses = Enum.GetNames(typeof(VaccineCompletionStatus));
            for (int i = 0; i < arrayCompletionStatuses.Length; i++)
            {
                listCompletionStatus.Items.Add(arrayCompletionStatuses[i]);
                VaccineCompletionStatus completionStatus = (VaccineCompletionStatus)i;
                if (completionStatus == VaccinePatCur.CompletionStatus)
                {
                    listCompletionStatus.SelectedIndex = i;
                }
            }
            textNote.Text = VaccinePatCur.Note;
            if (IsNew)
            {
                if (pat.ClinicNum == 0)
                {
                    VaccinePatCur.FilledCity = PrefC.GetString(PrefName.PracticeCity);
                    VaccinePatCur.FilledST   = PrefC.GetString(PrefName.PracticeST);
                }
                else
                {
                    Clinic clinic = Clinics.GetClinic(pat.ClinicNum);
                    VaccinePatCur.FilledCity = clinic.City;
                    VaccinePatCur.FilledST   = clinic.State;
                }
            }
            textFilledCity.Text = VaccinePatCur.FilledCity;
            textFilledSt.Text   = VaccinePatCur.FilledST;
            if (IsNew)
            {
                VaccinePatCur.UserNum = Security.CurUser.UserNum;
            }
            Userod user = Userods.GetUser(VaccinePatCur.UserNum);

            if (user != null)           //Will be null for vaccines entered in older versions, before the UserNum column was created.
            {
                textUser.Text = user.UserName;
            }
            _provNumSelectedOrdering = VaccinePatCur.ProvNumOrdering;
            comboProvNumOrdering.Items.Clear();
            _listProviders = Providers.GetDeepCopy(true);
            for (int i = 0; i < _listProviders.Count; i++)
            {
                comboProvNumOrdering.Items.Add(_listProviders[i].GetLongDesc());                //Only visible provs added to combobox.
                if (_listProviders[i].ProvNum == VaccinePatCur.ProvNumOrdering)
                {
                    comboProvNumOrdering.SelectedIndex = i;                  //Sets combo text too.
                }
            }
            if (comboProvNumOrdering.SelectedIndex == -1)                                    //The provider exists but is hidden
            {
                comboProvNumOrdering.Text = Providers.GetLongDesc(_provNumSelectedOrdering); //Appends "(hidden)" to the end of the long description.
            }
            _provNumSelectedAdministering = VaccinePatCur.ProvNumAdminister;
            comboProvNumAdministering.Items.Clear();
            for (int i = 0; i < _listProviders.Count; i++)
            {
                comboProvNumAdministering.Items.Add(_listProviders[i].GetLongDesc());                //Only visible provs added to combobox.
                if (_listProviders[i].ProvNum == VaccinePatCur.ProvNumAdminister)
                {
                    comboProvNumAdministering.SelectedIndex = i;                  //Sets combo text too.
                }
            }
            if (comboProvNumAdministering.SelectedIndex == -1)                                         //The provider exists but is hidden
            {
                comboProvNumAdministering.Text = Providers.GetLongDesc(_provNumSelectedAdministering); //Appends "(hidden)" to the end of the long description.
            }
            comboAdministrationRoute.Items.Clear();
            string[] arrayVaccineAdministrationRoutes = Enum.GetNames(typeof(VaccineAdministrationRoute));
            for (int i = 0; i < arrayVaccineAdministrationRoutes.Length; i++)
            {
                comboAdministrationRoute.Items.Add(arrayVaccineAdministrationRoutes[i]);
                VaccineAdministrationRoute administrationRoute = (VaccineAdministrationRoute)i;
                if (administrationRoute == VaccinePatCur.AdministrationRoute)
                {
                    comboAdministrationRoute.SelectedIndex = i;
                }
            }
            comboAdministrationSite.Items.Clear();
            string[] arrayVaccineAdministrationSites = Enum.GetNames(typeof(VaccineAdministrationSite));
            for (int i = 0; i < arrayVaccineAdministrationSites.Length; i++)
            {
                comboAdministrationSite.Items.Add(arrayVaccineAdministrationSites[i]);
                VaccineAdministrationSite administrationSite = (VaccineAdministrationSite)i;
                if (administrationSite == VaccinePatCur.AdministrationSite)
                {
                    comboAdministrationSite.SelectedIndex = i;
                }
            }
            listAdministrationNote.Items.Clear();
            string[] arrayAdministrationNotes = Enum.GetNames(typeof(VaccineAdministrationNote));
            for (int i = 0; i < arrayAdministrationNotes.Length; i++)
            {
                listAdministrationNote.Items.Add(arrayAdministrationNotes[i]);
                VaccineAdministrationNote administrationNote = (VaccineAdministrationNote)i;
                if (administrationNote == VaccinePatCur.AdministrationNoteCode)
                {
                    listAdministrationNote.SelectedIndex = i;
                }
            }
            listAction.Items.Clear();
            string[] arrayVaccineActions = Enum.GetNames(typeof(VaccineAction));
            for (int i = 0; i < arrayVaccineActions.Length; i++)
            {
                listAction.Items.Add(arrayVaccineActions[i]);
                VaccineAction action = (VaccineAction)i;
                if (action == VaccinePatCur.ActionCode)
                {
                    listAction.SelectedIndex = i;
                }
            }
            _listVaccineObservations = VaccineObses.GetForVaccine(VaccinePatCur.VaccinePatNum);
            FillObservations();
        }
Example #19
0
        private void comboVaccine_SelectedIndexChanged(object sender, EventArgs e)
        {
            DrugManufacturer manufacturer = DrugManufacturers.GetOne(_listVaccineDefs[comboVaccine.SelectedIndex].DrugManufacturerNum);

            textManufacturer.Text = manufacturer.ManufacturerCode + " - " + manufacturer.ManufacturerName;
        }