Changes in / [63d885e:ee137aa]


Ignore:
Files:
40 edited

Legend:

Unmodified
Added
Removed

  • Farmatiko/Controllers/HealthFacilitiesController.cs

    r63d885e ree137aa  
    2626        }
    2727        [HttpGet]
    28         public Task<IQueryable<HealthFacilities>> Get()
     28        public IQueryable<HealthFacilities> Get()
    2929        {
    3030            return _healthFacilitiesService.GetAll();

  • Farmatiko/Controllers/HealthcareWorkerController.cs

    r63d885e ree137aa  
    11using System.Linq;
    2 using System.Threading.Tasks;
    32using FarmatikoData.Models;
    43using FarmatikoServices.FarmatikoServiceInterfaces;
    … …  
    1817
    1918        [HttpGet]
    20         public Task<IQueryable<HealthcareWorkers>> Get()
     19        public IQueryable<HealthcareWorkers> Get()
    2120        {
    2221            return _healthcareWorkerService.GetAll();

  • Farmatiko/Controllers/MedicineController.cs

    r63d885e ree137aa  
    11using System.Linq;
    2 using System.Threading.Tasks;
    32using FarmatikoData.Models;
    43using FarmatikoServices.FarmatikoServiceInterfaces;
    … …  
    1716        }
    1817        [HttpGet]
    19         public Task<IQueryable<Medicine>> Get()
     18        public IQueryable<Medicine> Get()
    2019        {
    2120            return _medicineService.GetAll();

  • Farmatiko/Controllers/MedicineListController.cs

    r63d885e ree137aa  
    11using System.Collections.Generic;
    22using System.Linq;
    3 using System.Threading.Tasks;
    43using FarmatikoData.Models;
    54using FarmatikoServices.FarmatikoServiceInterfaces;
    … …  
    1817        }
    1918        [HttpGet]
    20         public Task<IQueryable<MedicineList>> Get()
     19        public IQueryable<MedicineList> Get()
    2120        {
    2221            return _medicineListService.GetAll();
    2322        }
    2423        [HttpGet]
    25         public Task<ICollection<MedicineList>> GetByName(string Name)
     24        public ICollection<MedicineList> GetByName(string Name)
    2625        {
    2726            return _medicineListService.GetByName(Name);
    2827        }
    2928        [HttpGet]
    30         public Task<ICollection<MedicineList>> GetByManufacturer(string Manufacturer)
     29        public ICollection<MedicineList> GetByManufacturer(string Manufacturer)
    3130        {
    3231            return _medicineListService.GetByManufacturer(Manufacturer);

  • Farmatiko/Controllers/PandemicController.cs

    r63d885e ree137aa  
    11using System.Linq;
    2 using System.Threading.Tasks;
    32using FarmatikoData.Models;
    43using FarmatikoServices.FarmatikoServiceInterfaces;
    … …  
    1716        }
    1817        [HttpGet]
    19         public Task<IQueryable<Pandemic>> Get()
     18        public IQueryable<Pandemic> Get()
    2019        {
    2120            return _pandemicService.GetAll();

  • Farmatiko/Controllers/PharmacyController.cs

    r63d885e ree137aa  
    11using System.Collections.Generic;
    22using System.Linq;
    3 using System.Threading.Tasks;
    43using FarmatikoData.Models;
    54using FarmatikoServices.FarmatikoServiceInterfaces;
    … …  
    1817        }
    1918        [HttpGet]
    20         public Task<IQueryable<Pharmacy>> Get()
     19        public IQueryable<Pharmacy> Get()
    2120        {
    2221            return _pharmacyService.GetAll();
    2322        }
    2423        [HttpGet]
    25         public Task<ICollection<Pharmacy>> GetPharmacies()
     24        public ICollection<Pharmacy> GetPharmacies()
    2625        {
    2726            return _pharmacyService.GetPharmacies();
    2827        }
    2928        [HttpPost]
    30         public void UpdatePharmacy(Pharmacy pharmacy)
     29        public void UpdatePharmacy(Pharmacy pharmacy, string Name)
    3130        {
    32             _pharmacyService.UpdatePharmacy(pharmacy);
     31            _pharmacyService.UpdatePharmacy(pharmacy,Name);
    3332        }
    3433        [HttpPost]

  • Farmatiko/Controllers/PharmacyHeadController.cs

    r63d885e ree137aa  
    3636        }
    3737        [HttpPost]
    38         public void Remove(PharmacyHead pharmacyHead)
     38        public void Remove(PharmacyHead pharmacyHead, string Name)
    3939        {
    40             _pharmacyHeadRepository.Remove(pharmacyHead);
     40            _pharmacyHeadRepository.Remove(pharmacyHead, Name);
    4141        }
    4242    }

  • Farmatiko/Startup.cs

    r63d885e ree137aa  
    1212using FarmatikoServices.FarmatikoServiceInterfaces;
    1313using FarmatikoServices.Services;
    14 using Microsoft.Extensions.Logging;
    1514
    1615namespace Farmatiko
    … …  
    7069
    7170            services.AddTransient<IProcessJSONService, ProcessJSONService>();
    72 
    73             services.AddTransient<ILogger, Logger<ProcessJSONService>>();
    7471        }
    7572

  • FarmatikoData/FarmatikoRepo/HealthFacilityRepository.cs

    r63d885e ree137aa  
    1616        public void Add(HealthFacilities healthFacility)
    1717        {
    18              _context.HealthFacilities.Add(healthFacility);
    19             _context.SaveChangesAsync();
     18            _context.Add(healthFacility);
     19            _context.SaveChanges();
    2020        }
    2121
    2222        public IQueryable<HealthFacilities> GetAll()
    2323        {
    24             return _context.HealthFacilities.Take(50).Select(x => new HealthFacilities
    25             {
    26                 Name = x.Name,
    27                 Municipality = x.Municipality,
    28                 Address = x.Address,
    29                 Type = x.Type,
    30                 Email = x.Email,
    31                 Phone = x.Phone
    32             }).OrderBy(x => x.Name);
    33         }
    34 
    35         public IQueryable<HealthFacilities> GetByName(string Name)
    36         {
    37             return _context.HealthFacilities.Where(x => x.Name.Equals(Name));
     24            return _context.HealthFacilities.OrderBy(x => x.Name);
    3825        }
    3926
    4027        public void Remove(HealthFacilities healthFacility)
    4128        {
    42             var facility = _context.HealthFacilities.Where(x => x.Name.Equals(healthFacility.Name)).FirstOrDefault();
    43             if (facility != null)
    44             {
    45                 _context.HealthFacilities.Remove(facility);
    46                 _context.SaveChangesAsync();
    47             }
    48            
     29            var facility = _context.HealthFacilities.Where(x => x.Name.Equals(healthFacility.Name));
     30            _context.HealthFacilities.Remove((HealthFacilities)facility);
    4931        }
    5032    }

  • FarmatikoData/FarmatikoRepo/HealthcareWorkerRepository.cs

    r63d885e ree137aa  
    22using FarmatikoData.Models;
    33using System.Linq;
    4 using System.Threading.Tasks;
    54
    65namespace FarmatikoData.FarmatikoRepo
    … …  
    2423        public IQueryable<HealthcareWorkers> GetAll()
    2524        {
    26             return _context.HealthcareWorkers.Take(50).Select(x => new HealthcareWorkers
    27             {
    28                 Name = x.Name,
    29                 Branch = x.Branch,
    30                 Facility = x.Facility,
    31                 Title = x.Title
    32             }).OrderBy(x => x.Name);
     25            return _context.HealthcareWorkers.OrderBy(x => x.Name);
    3326        }
    3427
    3528        public void Remove(HealthcareWorkers healthcareWorker)
    3629        {
    37             var healthCareWorker = _context.HealthcareWorkers.Where(x => x.Name.Equals(healthcareWorker.Name)).FirstOrDefault();
    38             if (healthCareWorker != null)
    39             {
    40                 _context.HealthcareWorkers.Remove(healthCareWorker);
    41                 _context.SaveChangesAsync();
    42             }
    43            
     30            var healthCareWorker = _context.HealthcareWorkers.Where(x => x.Name.Equals(healthcareWorker.Name));
     31            _context.HealthcareWorkers.Remove((HealthcareWorkers)healthCareWorker);
    4432        }
    4533    }

  • FarmatikoData/FarmatikoRepo/MedicineListRepository.cs

    r63d885e ree137aa  
    2929        public IQueryable<MedicineList> GetAll()
    3030        {
    31             return _context.MedicineLists.Take(50).Select(x => new MedicineList
    32             {
    33                 Medicine = x.Medicine,
    34                 HasMedicine = x.HasMedicine
    35             }).OrderBy(x => x.Medicine.Name);
     31            return _context.MedicineLists.OrderBy(x => x.Medicine.Name);
    3632        }
    3733
    3834        public ICollection<MedicineList> GetByManufacturer(string Manufacturer)
    3935        {
    40             return (ICollection<MedicineList>)_context.MedicineLists.Take(50)
     36            return (ICollection<MedicineList>)_context.MedicineLists
    4137                .Where(x => x.Medicine.Manufacturer.Contains(Manufacturer))
    42                 .Select(x => new MedicineList
    43                 {
    44                     Medicine = x.Medicine,
    45                     HasMedicine = x.HasMedicine
    46                 })
    4738                .OrderBy(x => x.Medicine.Name)
    4839                .Cast<ICollection<MedicineList>>();
    … …  
    5041        public ICollection<MedicineList> GetByName(string Name)
    5142        {
    52             return (ICollection<MedicineList>)_context.MedicineLists.Take(50)
     43            return (ICollection<MedicineList>)_context.MedicineLists
    5344                .Where(x => x.Medicine.Name.Contains(Name))
    54                 .Select(x => new MedicineList
    55                 {
    56                     Medicine = x.Medicine,
    57                     HasMedicine = x.HasMedicine
    58                 })
    5945                .OrderBy(x => x.Medicine.Name)
    6046                .Cast<ICollection<MedicineList>>();
    … …  
    6349        public void Remove(MedicineList medicineList)
    6450        {
    65             var list = _context.MedicineLists.Where(x => x.Medicine.Equals(medicineList.Medicine)).FirstOrDefault();
    66             if (list != null)
    67             {
    68                 _context.MedicineLists.Remove(list);
    69                 _context.SaveChangesAsync();
    70             }
     51            var list = (MedicineList)_context.MedicineLists.Where(x => x.Medicine.Equals(medicineList.Medicine));
     52            _context.MedicineLists.Remove(list);
    7153        }
    7254    }

  • FarmatikoData/FarmatikoRepo/MedicineRepository.cs

    r63d885e ree137aa  
    2121        public IQueryable<Medicine> GetAll()
    2222        {
    23             return _context.Medicines.Take(50).Select(x => new Medicine
    24             {
    25                 Name = x.Name,
    26                 Strength = x.Strength,
    27                 Form = x.Form,
    28                 WayOfIssuing = x.WayOfIssuing,
    29                 Manufacturer = x.Manufacturer,
    30                 Price = x.Price,
    31                 Packaging = x.Packaging
    32             }).OrderBy(x => x.Name);
     23            return _context.Medicines.OrderBy(x => x.Name);
    3324        }
    3425
    3526        public IQueryable<Medicine> GetByManufacturer(string Manufacturer)
    3627        {
    37             return _context.Medicines.Take(50).Where(x => x.Name.Contains(Manufacturer))
    38                 .Select(x => new Medicine
    39                 {
    40                     Name = x.Name,
    41                     Strength = x.Strength,
    42                     Form = x.Form,
    43                     WayOfIssuing = x.WayOfIssuing,
    44                     Manufacturer = x.Manufacturer,
    45                     Price = x.Price,
    46                     Packaging = x.Packaging
    47                 }).OrderBy(x => x.Manufacturer);
     28            return _context.Medicines.Where(x => x.Name.Contains(Manufacturer)).OrderBy(x => x.Manufacturer);
    4829        }
    4930
    5031        public IQueryable<Medicine> GetByName(string Name)
    5132        {
    52             return _context.Medicines.Take(50).Where(medicine => medicine.Name.Contains(Name))
    53                 .Select(x => new Medicine
    54                 {
    55                     Name = x.Name,
    56                     Strength = x.Strength,
    57                     Form = x.Form,
    58                     WayOfIssuing = x.WayOfIssuing,
    59                     Manufacturer = x.Manufacturer,
    60                     Price = x.Price,
    61                     Packaging = x.Packaging
    62                 }).OrderBy(x => x.Name);
     33            return _context.Medicines.Where(medicine => medicine.Name.Contains(Name)).OrderBy(x => x.Name);
    6334        }
    6435
    65         public void Remove(Medicine medicine)
     36        public void Remove(string medicine)
    6637        {
    67             Medicine med = _context.Medicines.Where(medicine => medicine.Name.Equals(medicine.Name)).FirstOrDefault();
    68             if (med != null)
    69             {
    70                 _context.Medicines.Remove(med);
    71                 _context.SaveChangesAsync();
    72             }
    73 
     38            Medicine med = (Medicine)_context.Medicines.Where(medicine => medicine.Name.Equals(medicine));
     39            _context.Medicines.Remove(med);
    7440        }
    7541    }

  • FarmatikoData/FarmatikoRepo/PandemicRepository.cs

    r63d885e ree137aa  
    2222        public IQueryable<Pandemic> GetAll()
    2323        {
    24             return _context.Pandemics.Select(x => new Pandemic
    25             {
    26                 Name = x.Name,
    27                 TotalMK = x.TotalMK,
    28                 ActiveMK = x.ActiveMK,
    29                 DeathsMK = x.DeathsMK,
    30                 NewMK = x.NewMK,
    31                 TotalGlobal = x.TotalGlobal,
    32                 DeathsGlobal = x.DeathsGlobal,
    33                 ActiveGlobal = x.ActiveGlobal
    34             }).OrderBy(x => x.Name);
     24            return _context.Pandemics.OrderBy(x => x.Name);
    3525        }
    3626
    3727        public void Remove(Pandemic pandemic)
    3828        {
    39             var Pandem = _context.Pandemics.Where(x => x.Name.Equals(pandemic.Name)).FirstOrDefault();
    40             if (Pandem != null)
    41             {
    42                 _context.Pandemics.Remove(Pandem);
    43                 _context.SaveChangesAsync();
    44             }
     29            _context.Pandemics.Remove(pandemic);
     30            _context.SaveChangesAsync();
    4531        }
    4632    }

  • FarmatikoData/FarmatikoRepo/PharmacyHeadRepository.cs

    r63d885e ree137aa  
    2222        public IQueryable<PharmacyHead> GetAllPharmacies(string NameOfPharmacyHeads)
    2323        {
    24             return _context.PharmacyHeads.Where(pharmacyHead => pharmacyHead.Name.Contains(NameOfPharmacyHeads))
    25                 .Take(10).Select(x => new PharmacyHead
    26                 {
    27                     MedicineLists = x.MedicineLists,
    28                     PharmaciesList = x.PharmaciesList,
    29                     Email = x.Email,
    30                     Name = x.Name,
    31                 }).OrderBy(x => x.Name);
     24            return _context.PharmacyHeads
     25                .Where(pharmacyHead => pharmacyHead.Name.Contains(NameOfPharmacyHeads))
     26                .OrderBy(x => x.Name);
    3227        }
    3328        //Not needed
    3429        public IQueryable<PharmacyHead> GetPharmacyByName(string Name)
    3530        {
    36             return _context.PharmacyHeads.Take(10)
    37                 .Where(pharmacyHead => pharmacyHead.Name.Equals(Name))
    38                 .Select(x => new PharmacyHead
    39                 {
    40                     MedicineLists = x.MedicineLists,
    41                     PharmaciesList = x.PharmaciesList,
    42                     Email = x.Email,
    43                     Name = x.Name,
    44                 }).OrderBy(x => x.Name);
     31            return _context.PharmacyHeads.Where(pharmacyHead => pharmacyHead.Name.Equals(Name));
    4532        }
    4633
    … …  
    4835        {
    4936
    50             IQueryable<MedicineList> Pharmacy = (IQueryable<MedicineList>)_context.PharmacyHeads
    51                 .Take(50)
    52                 .Where(x => x.Name.Equals(NameOfPharmacy))
    53                 .Select(x => new PharmacyHead
    54                 {
    55                     MedicineLists = x.MedicineLists
    56                 }).OrderBy(x => x.Name);
    57 
     37            IQueryable<MedicineList> Pharmacy = (IQueryable<MedicineList>)_context.PharmacyHeads.Where(x => x.Name.Equals(NameOfPharmacy));
     38           
    5839            return Pharmacy;
    5940        }
    6041
    61         public void Remove(PharmacyHead pharmacyHead)
     42        public void Remove(PharmacyHead pharmacyHead, string Name)
    6243        {
    63             var phead = _context.PharmacyHeads.Where(phead => phead.Name.Equals(pharmacyHead.Name)).FirstOrDefault();
    64             if (phead != null)
    65             {
    66                 _context.PharmacyHeads.Remove(phead);
    67                 _context.SaveChangesAsync();
    68             }
     44            var phead = (PharmacyHead)_context.PharmacyHeads.Where(phead => phead.Name.Equals(Name)).FirstOrDefault();
     45            _context.PharmacyHeads.Remove(phead);
     46            _context.SaveChangesAsync();
    6947        }
    7048    }

  • FarmatikoData/FarmatikoRepo/PharmacyRepository.cs

    r63d885e ree137aa  
    11using FarmatikoData.FarmatikoRepoInterfaces;
    22using FarmatikoData.Models;
    3 using System;
    43using System.Collections.Generic;
    54using System.Linq;
    … …  
    1918        {
    2019            _context.Pharmacies.Add(pharmacy);
    21             _context.SaveChanges();
     20            _context.SaveChangesAsync();
    2221        }
    2322        //Just for users
    2423        public IQueryable<Pharmacy> GetAll()
    2524        {
    26             return _context.Pharmacies.Take(50)
    27                 .Select(x => new Pharmacy
    28                 {
    29                     Name = x.Name,
    30                     Location = x.Location,
    31                     Address = x.Address,
    32                     WorkAllTime = x.WorkAllTime
    33                 }).OrderBy(x => x.Name);
     25            return _context.Pharmacies.OrderBy(x => x.Name);
    3426        }
    3527
    3628        public ICollection<Pharmacy> GetPharmacies()
    3729        {
    38             return (ICollection<Pharmacy>)_context.Pharmacies.Take(50)
    39                 .Select(pharmacy => new
    40                 {
    41                     pharmacy.Name,
    42                     pharmacy.Address,
    43                     pharmacy.Location,
    44                     pharmacy.WorkAllTime
    45                 }).OrderBy(x => x.Name);
     30            return (ICollection<Pharmacy>)_context.Pharmacies.Select(pharmacy => new
     31            {
     32                pharmacy.Name,
     33                pharmacy.Address,
     34                pharmacy.Location,
     35                pharmacy.WorkAllTime
     36            }).OrderBy(x => x.Name);
    4637        }
    4738
    4839        public void Remove(Pharmacy pharmacy)
    4940        {
    50             var pharma = _context.Pharmacies.Where(pharm => pharm.Name.Equals(pharmacy.Name)).FirstOrDefault();
    51             if (pharma != null)
    52             {
    53                 _context.Pharmacies.Remove(pharmacy);
    54                 _context.SaveChangesAsync();
    55             }
     41            var pharma = _context.Pharmacies.Where(pharm => pharm.Name.Equals(pharmacy.Name)).Cast<Pharmacy>();
     42            _context.Pharmacies.Remove((Pharmacy)pharma);
     43            _context.SaveChangesAsync();
    5644        }
    5745
    58         public void UpdatePharmacy(Pharmacy pharmacy)
     46        public void UpdatePharmacy(Pharmacy pharmacy, string Name)
    5947        {
    60             var oldPharmacy = _context.Pharmacies.Where(pharma => pharma.Name.Equals(pharmacy.Name)).FirstOrDefault();
    61             if (oldPharmacy != null)
    62             {
    63                 _context.Pharmacies.Remove(oldPharmacy);
    64                 _context.Pharmacies.Add(pharmacy);
    65                 _context.SaveChangesAsync();
    66             }
    67             throw new Exception("Pharmacy not found");
     48            var oldPharmacy = _context.Pharmacies.Where(pharma => pharma.Name.Equals(Name)).Cast<Pharmacy>();
     49            _context.Pharmacies.Remove((Pharmacy)oldPharmacy);
     50            _context.Pharmacies.Add(pharmacy);
     51            _context.SaveChangesAsync();
    6852        }
    6953    }

  • FarmatikoData/FarmatikoRepoInterfaces/IHealthFacilityRepository.cs

    r63d885e ree137aa  
    99        void Add(HealthFacilities healthFacility);
    1010        void Remove(HealthFacilities healthFacility);
    11         IQueryable<HealthFacilities> GetByName(string Name);
    1211    }
    1312}

  • FarmatikoData/FarmatikoRepoInterfaces/IMedicineRepository.cs

    r63d885e ree137aa  
    99        IQueryable<Medicine> GetByName(string Name);
    1010        void Add(Medicine medicine);
    11         void Remove(Medicine medicine);
     11        void Remove(string medicine);
    1212        IQueryable<Medicine> GetByManufacturer(string Manufacturer);
    1313

  • FarmatikoData/FarmatikoRepoInterfaces/IPharmacyHeadRepository.cs

    r63d885e ree137aa  
    77    {
    88        void Add(PharmacyHead pharmacyHead);
    9         void Remove(PharmacyHead pharmacyHead);
     9        void Remove(PharmacyHead pharmacyHead, string Name);
    1010        IQueryable<PharmacyHead> GetAllPharmacies(string NameOfPharmacyHead);
    1111        //Not actually needed

  • FarmatikoData/FarmatikoRepoInterfaces/IPharmacyRepository.cs

    r63d885e ree137aa  
    1111        IQueryable<Pharmacy> GetAll();
    1212        void Remove(Pharmacy pharmacy);
    13         void UpdatePharmacy(Pharmacy pharmacy);
     13        void UpdatePharmacy(Pharmacy pharmacy, string Name);
    1414
    1515    }

  • FarmatikoData/Models/HealthFacilities.cs

    r63d885e ree137aa  
    2222        public string Email { get; set; }
    2323        public string Phone { get; set; }
    24         public HealthFacilities(string Name, string Municipality, string Address, string Type, string Email, string Phone)
    25         {
    26             this.Name = Name;
    27             this.Municipality = Municipality;
    28             this.Address = Address;
    29             this.Type = Type;
    30             this.Email = Email;
    31             this.Phone = Phone;
    32         }
    3324    }
    3425}

  • FarmatikoData/Models/HealthcareWorkers.cs

    r63d885e ree137aa  
    1818        public HealthFacilities Facility { get; set; }
    1919        public string Title { get; set; }
    20         public HealthcareWorkers(string Name, string Branch, HealthFacilities Facility, string Title)
    21         {
    22             this.Name = Name;
    23             this.Branch = Branch;
    24             this.Facility = Facility;
    25             this.Title = Title;
    26         }
    2720    }
    2821}

  • FarmatikoData/Models/Medicine.cs

    r63d885e ree137aa  
    1313        public float Price { get; set; }
    1414        public string Packaging { get; set; }
    15         public Medicine(string Name, string Strength, string Form, string WayOfIssuing, string Manufacturer, float Price, string Packaging)
    16         {
    17             this.Name = Name;
    18             this.Strength = Strength;
    19             this.Form = Form;
    20             this.WayOfIssuing = WayOfIssuing;
    21             this.Manufacturer = Manufacturer;
    22             this.Price = Price;
    23             this.Packaging = Packaging;
    24         }
    2515
    2616    }

  • FarmatikoData/Models/MedicineList.cs

    r63d885e ree137aa  
    88    public class MedicineList : BaseEntity
    99    {
    10         public MedicineList()
    11         {
    12         }
    1310        public Medicine Medicine { get; set; }
    1411        public bool HasMedicine { get; set; }
    15         public MedicineList(Medicine Medicine, bool HasMedicine)
    16         {
    17             this.Medicine = Medicine;
    18             this.HasMedicine = HasMedicine;
    19         }
    2012        /*public ICollection<MedicineList> MedicinesList { get; set; }
    2113        public MedicineList()

  • FarmatikoData/Models/Pharmacy.cs

    r63d885e ree137aa  
    1414        public string Address { get; set; }
    1515        public bool WorkAllTime { get; set; }
    16         public Pharmacy(string Name, string Location, string Address, bool WorkAllTime)
    17         {
    18             this.Name = Name;
    19             this.Location = Location;
    20             this.Address = Address;
    21             this.WorkAllTime = WorkAllTime;
    22         }
    2316    }
    2417}

  • FarmatikoServices/FarmatikoServiceInterfaces/IHealthFacilityService.cs

    r63d885e ree137aa  
    11using FarmatikoData.Models;
    22using System.Linq;
    3 using System.Threading.Tasks;
    43
    54namespace FarmatikoData
    … …  
    76    public interface IHealthFacilityService
    87    {
    9         Task<IQueryable<HealthFacilities>> GetAll();
     8        IQueryable<HealthFacilities> GetAll();
    109        void Add(HealthFacilities healthFacility);
    1110        void Remove(HealthFacilities healthFacility);

  • FarmatikoServices/FarmatikoServiceInterfaces/IHealthcareWorkerService.cs

    r63d885e ree137aa  
    11using FarmatikoData.Models;
    22using System.Linq;
    3 using System.Threading.Tasks;
    43
    54namespace FarmatikoServices.FarmatikoServiceInterfaces
    … …  
    76    public interface IHealthcareWorkerService
    87    {
    9         Task<IQueryable<HealthcareWorkers>> GetAll();
     8        IQueryable<HealthcareWorkers> GetAll();
    109        void Add(HealthcareWorkers healthcareWorker);
    1110        void Remove(HealthcareWorkers healthcareWorker);

  • FarmatikoServices/FarmatikoServiceInterfaces/IMedicineListService.cs

    r63d885e ree137aa  
    22using System.Collections.Generic;
    33using System.Linq;
    4 using System.Threading.Tasks;
    54
    65namespace FarmatikoServices.FarmatikoServiceInterfaces
    … …  
    87    public interface IMedicineListService
    98    {
    10         Task<IQueryable<MedicineList>> GetAll();
     9        IQueryable<MedicineList> GetAll();
    1110        //SetHasMedicine(MedicineList medicineList, bool HasMedicine);
    12         Task<ICollection<MedicineList>> GetByName(string Name);
    13         Task<ICollection<MedicineList>> GetByManufacturer(string Manufacturer);
     11        ICollection<MedicineList> GetByName(string Name);
     12        ICollection<MedicineList> GetByManufacturer(string Manufacturer);
    1413        void Add(MedicineList medicineList);
    1514        void Remove(MedicineList medicineList);

  • FarmatikoServices/FarmatikoServiceInterfaces/IMedicineService.cs

    r63d885e ree137aa  
    11using FarmatikoData.Models;
    22using System.Linq;
    3 using System.Threading.Tasks;
    43
    54namespace FarmatikoServices.FarmatikoServiceInterfaces
    … …  
    76    public interface IMedicineService
    87    {
    9         Task<IQueryable<Medicine>> GetAll();
     8        IQueryable<Medicine> GetAll();
    109        void Add(Medicine medicine);
    11         void Remove(Medicine Medicine);
    12         Task<IQueryable<Medicine>> GetByName(string Name);
    13         Task<IQueryable<Medicine>> GetByManufacturer(string Manufacturer);
     10        void Remove(string Medicine);
     11        IQueryable<Medicine> GetByName(string Name);
     12        IQueryable<Medicine> GetByManufacturer(string Manufacturer);
    1413    }
    1514}

  • FarmatikoServices/FarmatikoServiceInterfaces/IPandemicService.cs

    r63d885e ree137aa  
    11using FarmatikoData.Models;
    22using System.Linq;
    3 using System.Threading.Tasks;
    43
    54namespace FarmatikoServices.FarmatikoServiceInterfaces
    … …  
    87    {
    98        void Add(Pandemic pandemic);
    10         Task<IQueryable<Pandemic>> GetAll();
     9        IQueryable<Pandemic> GetAll();
    1110        void Remove(Pandemic pandemic);
    1211    }

  • FarmatikoServices/FarmatikoServiceInterfaces/IPharmacyHeadService.cs

    r63d885e ree137aa  
    11using FarmatikoData.Models;
    22using System.Linq;
    3 using System.Threading.Tasks;
    43
    54namespace FarmatikoServices.FarmatikoServiceInterfaces
    … …  
    87    {
    98        void Add(PharmacyHead pharmacyHead);
    10         void Remove(PharmacyHead pharmacyHead);
    11         Task<IQueryable<PharmacyHead>> GetAllPharmacies(string NameOfPharmacyHead);
     9        void Remove(PharmacyHead pharmacyHead, string Name);
     10        IQueryable<PharmacyHead> GetAllPharmacies(string NameOfPharmacyHead);
    1211        //Not actually needed
    13         Task<IQueryable<PharmacyHead>> GetPharmacyByName(string Name);
    14         Task<IQueryable<MedicineList>> GetPharmacyMedicines(string NameOfPharmacy);
     12        IQueryable<PharmacyHead> GetPharmacyByName(string Name);
     13        IQueryable<MedicineList> GetPharmacyMedicines(string NameOfPharmacy);
    1514    }
    1615}

  • FarmatikoServices/FarmatikoServiceInterfaces/IPharmacyService.cs

    r63d885e ree137aa  
    22using System.Collections.Generic;
    33using System.Linq;
    4 using System.Threading.Tasks;
    54
    65namespace FarmatikoServices.FarmatikoServiceInterfaces
    … …  
    98    {
    109        void Add(Pharmacy pharmacy);
    11         Task<ICollection<Pharmacy>> GetPharmacies();
    12         Task<IQueryable<Pharmacy>> GetAll();
     10        ICollection<Pharmacy> GetPharmacies();
     11        IQueryable<Pharmacy> GetAll();
    1312        void Remove(Pharmacy pharmacy);
    14         void UpdatePharmacy(Pharmacy pharmacy);
     13        void UpdatePharmacy(Pharmacy pharmacy, string Name);
    1514    }
    1615}

  • FarmatikoServices/FarmatikoServiceInterfaces/IProcessJSONService.cs

    r63d885e ree137aa  
    33using System.Collections.Generic;
    44using System.Text;
    5 using System.Threading.Tasks;
    65
    76namespace FarmatikoServices.FarmatikoServiceInterfaces
    … …  
    98    public interface IProcessJSONService
    109    {
    11         Task<HashSet<HealthFacilities>> GetProcessedHealthFacilitiesFromJSON();
    12         Task<HashSet<Pandemic>> GetProcessedPandemicsFromJSONApi();
    13         Task<HashSet<HealthcareWorkers>> GetProcessedHealthcareWorkersFromJSON();
    14         Task<HashSet<Medicine>> GetProcessedMedicinesFromJSON();
     10        List<HealthFacilities> GetProcessedHealthFacilitiesFromJSON();
    1511    }
    1612}

  • FarmatikoServices/Services/HealthFacilityService.cs

    r63d885e ree137aa  
    44using System;
    55using System.Linq;
    6 using System.Threading.Tasks;
    76
    87namespace FarmatikoServices
    … …  
    1716        }
    1817
    19         public async void Add(HealthFacilities healthFacility)
     18        public void Add(HealthFacilities healthFacility)
    2019        {
    21             if (healthFacility != null)
    22                 await Task.Run(() => _healthFacilityRepository.Add(healthFacility));
    23             else throw new Exception("Can't add, health facility is null");
     20            try
     21            {
     22                if (healthFacility != null)
     23                    _healthFacilityRepository.Add(healthFacility);
     24            }
     25            catch (Exception e)
     26            {
     27                e = new Exception("Can't Add health facility is null");
     28                throw e;
     29            }
    2430        }
    2531
    26         public async Task<IQueryable<HealthFacilities>> GetAll()
     32        public IQueryable<HealthFacilities> GetAll()
    2733        {
    28             return await Task.Run(() => _healthFacilityRepository.GetAll());
     34            return _healthFacilityRepository.GetAll();
    2935        }
    3036
    31         public async void Remove(HealthFacilities healthFacility)
     37        public void Remove(HealthFacilities healthFacility)
    3238        {
    33             if (healthFacility != null)
    34                 await Task.Run(() => _healthFacilityRepository.Remove(healthFacility));
    35             else throw new Exception("Can't Remove health facility is null");
    36 
     39            try
     40            {
     41                if (healthFacility != null)
     42                    _healthFacilityRepository.Remove(healthFacility);
     43            }
     44            catch(Exception e)
     45            {
     46                e = new Exception("Can't Remove health facility is null");
     47                throw e;
     48            }
    3749        }
    3850    }

  • FarmatikoServices/Services/HealthcareWorkerService.cs

    r63d885e ree137aa  
    44using System;
    55using System.Linq;
    6 using System.Threading.Tasks;
    76
    87namespace FarmatikoServices.Services
    … …  
    1514            _healthcareWorkerRepo = healthcareWorkerRepo;
    1615        }
    17         public async void Add(HealthcareWorkers healthcareWorker)
     16        public void Add(HealthcareWorkers healthcareWorker)
    1817        {
    19             if (healthcareWorker != null)
    20                 await Task.Run(() => _healthcareWorkerRepo.Add(healthcareWorker));
    21             else throw new Exception("Can't add, healthcare worker is null");
     18            try
     19            {
     20                if (healthcareWorker != null)
     21                    _healthcareWorkerRepo.Add(healthcareWorker);
     22            }
     23            catch (Exception e)
     24            {
     25                e = new Exception("Can't Add healthcare worker is null");
     26                throw e;
     27            }
    2228        }
    2329
    24         public async Task<IQueryable<HealthcareWorkers>> GetAll()
     30        public IQueryable<HealthcareWorkers> GetAll()
    2531        {
    26             var healthCareWorkers = await Task.Run(() => _healthcareWorkerRepo.GetAll());
    27             if (healthCareWorkers != null)
    28                 return healthCareWorkers;
    29             return null;
     32            return _healthcareWorkerRepo.GetAll();
    3033        }
    3134
    32         public async void Remove(HealthcareWorkers healthcareWorker)
     35        public void Remove(HealthcareWorkers healthcareWorker)
    3336        {
    34             if (healthcareWorker != null)
    35                 await Task.Run(() => _healthcareWorkerRepo.Remove(healthcareWorker));
    36             else throw new Exception("Can't Remove healthcare worker is null");
     37            try
     38            {
     39                if (healthcareWorker != null)
     40                    _healthcareWorkerRepo.Remove(healthcareWorker);
     41            }
     42            catch (Exception e)
     43            {
     44                e = new Exception("Can't Remove healthcare worker is null");
     45                throw e;
     46            }
    3747        }
    3848    }

  • FarmatikoServices/Services/MedicineListService.cs

    r63d885e ree137aa  
    55using System.Collections.Generic;
    66using System.Linq;
    7 using System.Threading.Tasks;
    87
    98namespace FarmatikoServices.Services
    … …  
    1716        }
    1817
    19         public async void Add(MedicineList medicineList)
     18        public void Add(MedicineList medicineList)
    2019        {
    21             if (medicineList != null)
    22                 await Task.Run(() => _medicineListRepository.Add(medicineList));
    23             else throw new Exception("Can't add, the medicine list is null.");
     20            try
     21            {
     22                if (medicineList != null)
     23                    _medicineListRepository.Add(medicineList);
     24            }
     25            catch (Exception e)
     26            {
     27                e = new Exception("Can't add the medicine list is null.");
     28                throw e;
     29            }
    2430        }
    2531
    26         public async Task<IQueryable<MedicineList>> GetAll()
     32        public IQueryable<MedicineList> GetAll()
    2733        {
    28             return await Task.Run(() => _medicineListRepository.GetAll());
     34            return _medicineListRepository.GetAll();
    2935        }
    3036
    31         public async Task<ICollection<MedicineList>> GetByManufacturer(string Manufacturer)
     37        public ICollection<MedicineList> GetByManufacturer(string Manufacturer)
    3238        {
    33             if (Manufacturer != null)
    34                 return await Task.Run(() => _medicineListRepository.GetByManufacturer(Manufacturer));
    35             else throw new Exception("Can't get, name of manufacturer is null");
     39            try
     40            {
     41                if (Manufacturer != null)
     42                {
     43
     44                    return _medicineListRepository.GetByManufacturer(Manufacturer);
     45                }
     46            }
     47            catch (Exception e)
     48            {
     49                e = new Exception("Can't get name of manufacturer is null");
     50                throw e;
     51            }
     52            return null;
    3653        }
    3754
    38         public async Task<ICollection<MedicineList>> GetByName(string Name)
     55        public ICollection<MedicineList> GetByName(string Name)
    3956        {
    40             if (Name != null)
    41                 return await Task.Run(() => _medicineListRepository.GetByName(Name));
    42             else throw new Exception("Can't get, name is null");
     57            try
     58            {
     59                if (Name != null)
     60                {
     61                    return _medicineListRepository.GetByName(Name);
     62                }
     63            }
     64            catch (Exception e)
     65            {
     66                e = new Exception("Can't get name is null");
     67                throw e;
     68            }
     69            return null;
    4370        }
    4471
    45         public async void Remove(MedicineList medicineList)
     72        public void Remove(MedicineList medicineList)
    4673        {
    47             if (medicineList != null)
    48                 await Task.Run(() => _medicineListRepository.Remove(medicineList));
    49             else throw new Exception("Can't remove, the medicine list is null.");
     74            try
     75            {
     76                if (medicineList != null)
     77                    _medicineListRepository.Remove(medicineList);
     78            }
     79            catch (Exception e)
     80            {
     81                e = new Exception("Can't remove the medicine list is null.");
     82                throw e;
     83            }
    5084        }
    5185    }

  • FarmatikoServices/Services/MedicineService.cs

    r63d885e ree137aa  
    55using System.Collections.Generic;
    66using System.Linq;
    7 using System.Threading.Tasks;
    87
    98namespace FarmatikoServices.Services
    … …  
    1716        }
    1817
    19         public async void Add(Medicine medicine)
     18        public void Add(Medicine medicine)
    2019        {
    21             if (medicine != null)
    22                 await Task.Run(() => _medicineRepository.Add(medicine));
    23             else throw new Exception("Can't Add medicine is null");
     20            try
     21            {
     22                if (medicine != null)
     23                    _medicineRepository.Add(medicine);
     24            }
     25            catch (Exception e)
     26            {
     27                e = new Exception("Can't Add medicine is null");
     28                throw e;
     29            }
    2430        }
    2531
    26         public async Task<IQueryable<Medicine>> GetAll()
     32        public IQueryable<Medicine> GetAll()
    2733        {
    28             return await Task.Run(() => _medicineRepository.GetAll());
     34            return _medicineRepository.GetAll();
    2935        }
    3036
    31         public async Task<IQueryable<Medicine>> GetByManufacturer(string Manufacturer)
     37        public IQueryable<Medicine> GetByManufacturer(string Manufacturer)
    3238        {
    33             if (Manufacturer != null)
    34                 return await Task.Run(() => _medicineRepository.GetByManufacturer(Manufacturer));
    35             else throw new Exception("Can't get, name of manufacturer is null");
     39            try
     40            {
     41                if (Manufacturer != null)
     42                    return _medicineRepository.GetByManufacturer(Manufacturer);
     43            }
     44            catch (Exception e)
     45            {
     46                e = new Exception("Can't get, name of manufacturer is null");
     47                throw e;
     48            }
     49           
     50            return null;
    3651        }
    3752
    38         public async Task<IQueryable<Medicine>> GetByName(string Name)
     53        public IQueryable<Medicine> GetByName(string Name)
    3954        {
    40             if (Name != null)
    41                 return await Task.Run(() => _medicineRepository.GetByName(Name));
    42             else throw new Exception("Can't get, name is null");
     55            try
     56            {
     57                if (Name != null)
     58                    return _medicineRepository.GetByName(Name);
     59            }
     60            catch (Exception e)
     61            {
     62                e = new Exception("Can't get, name is null");
     63            }
     64           
     65            return null;
    4366        }
    4467
    45         public async void Remove(Medicine Medicine)
     68        public void Remove(string Medicine)
    4669        {
    47             if (Medicine != null)
    48                 await Task.Run(() => _medicineRepository.Remove(Medicine));
    49             else throw new Exception("Can't Add medicine is null");
     70            try
     71            {
     72                if (Medicine != null)
     73                    _medicineRepository.Remove(Medicine);
     74            }
     75            catch (Exception e)
     76            {
     77                e = new Exception("Can't Add medicine is null");
     78                throw e;
     79            }
    5080        }
    5181    }

  • FarmatikoServices/Services/PandemicService.cs

    r63d885e ree137aa  
    44using System;
    55using System.Linq;
    6 using System.Threading.Tasks;
    76
    87namespace FarmatikoServices.Services
    … …  
    1615        }
    1716
    18         public async void Add(Pandemic pandemic)
     17        public void Add(Pandemic pandemic)
    1918        {
    20             if (pandemic != null)
    21                 await Task.Run(() => _pandemicRepository.Add(pandemic));
    22             else throw new Exception("Can't add pandemic is null.");
     19            try
     20            {
     21                if (pandemic != null)
     22                {
     23                    _pandemicRepository.Add(pandemic);
     24                }
     25            }
     26            catch (Exception e)
     27            {
     28                e = new Exception("Can't add pandemic is null.");
     29                throw e;
     30            }
    2331        }
    2432
    25         public async Task<IQueryable<Pandemic>> GetAll()
     33        public IQueryable<Pandemic> GetAll()
    2634        {
    27             return await Task.Run(() => _pandemicRepository.GetAll());
     35            return _pandemicRepository.GetAll();
    2836        }
    2937
    30         public async void Remove(Pandemic pandemic)
     38        public void Remove(Pandemic pandemic)
    3139        {
    32             if (pandemic != null)
    33                 await Task.Run(() => _pandemicRepository.Remove(pandemic));
    34             else throw new Exception("Can't remove, pandemic is null.");
     40            try
     41            {
     42                if (pandemic != null)
     43                    _pandemicRepository.Remove(pandemic);
     44            }
     45            catch (Exception e)
     46            {
     47                e = new Exception("Can't remove, pandemic is null.");
     48            }
    3549        }
    3650    }

  • FarmatikoServices/Services/PharmacyHeadService.cs

    r63d885e ree137aa  
    44using System;
    55using System.Linq;
    6 using System.Threading.Tasks;
    76
    87namespace FarmatikoServices.Services
    … …  
    1615        }
    1716
    18         public async void Add(PharmacyHead pharmacyHead)
     17        public void Add(PharmacyHead pharmacyHead)
    1918        {
    20             if (pharmacyHead != null)
    21                 await Task.Run(() => _pharmacyHeadRepository.Add(pharmacyHead));
    22             else throw new Exception("Can't add, pharmacy head is null.");
     19            try
     20            {
     21                if (pharmacyHead != null)
     22                {
     23                    _pharmacyHeadRepository.Add(pharmacyHead);
     24                }
     25            }
     26            catch (Exception e)
     27            {
     28                e = new Exception("Can't add, pharmacy head is null.");
     29            }
     30
    2331        }
    2432
    25         public async Task<IQueryable<PharmacyHead>> GetAllPharmacies(string NameOfPharmacyHead)
     33        public IQueryable<PharmacyHead> GetAllPharmacies(string NameOfPharmacyHead)
    2634        {
    2735            if (NameOfPharmacyHead != null)
    2836            {
    29                 IQueryable<PharmacyHead> pharmacies = await Task.Run(() => _pharmacyHeadRepository.GetAllPharmacies(NameOfPharmacyHead));
    30                 if (pharmacies != null)
    31                     return pharmacies;
     37                IQueryable<PharmacyHead> Pharmacy = _pharmacyHeadRepository.GetAllPharmacies(NameOfPharmacyHead);
     38                if (Pharmacy != null)
     39                    return Pharmacy;
    3240            }
    3341            return null;
    3442        }
    3543
    36         public async Task<IQueryable<PharmacyHead>> GetPharmacyByName(string Name)
     44        public IQueryable<PharmacyHead> GetPharmacyByName(string Name)
    3745        {
    3846            if (Name != null)
    3947            {
    40                 IQueryable<PharmacyHead> PharmacyHead = await Task.Run(() => _pharmacyHeadRepository.GetPharmacyByName(Name));
     48                IQueryable<PharmacyHead> PharmacyHead = _pharmacyHeadRepository.GetPharmacyByName(Name);
    4149                if (PharmacyHead != null)
    4250                    return PharmacyHead;
    … …  
    4553        }
    4654
    47         public async Task<IQueryable<MedicineList>> GetPharmacyMedicines(string NameOfPharmacy)
     55        public IQueryable<MedicineList> GetPharmacyMedicines(string NameOfPharmacy)
    4856        {
    4957            if (NameOfPharmacy != null)
    5058            {
    51                 IQueryable<MedicineList> Medicines = await Task.Run(() => _pharmacyHeadRepository.GetPharmacyMedicines(NameOfPharmacy));
     59                IQueryable<MedicineList> Medicines = _pharmacyHeadRepository.GetPharmacyMedicines(NameOfPharmacy);
    5260                if (Medicines != null)
    5361                    return Medicines;
    … …  
    5664        }
    5765
    58         public async void Remove(PharmacyHead pharmacyHead)
     66        public void Remove(PharmacyHead pharmacyHead, string Name)
    5967        {
    60             if (pharmacyHead != null)
    61                 await Task.Run(() => _pharmacyHeadRepository.Remove(pharmacyHead));
    62             else throw new Exception("Can't remove, name of pharmacy head is null.");
     68            try
     69            {
     70                if (Name != null)
     71                {
     72                    _pharmacyHeadRepository.Remove(pharmacyHead, Name);
     73                }
     74            }
     75            catch (Exception e)
     76            {
     77                e = new Exception("Can't remove, name of pharmacy head is null.");
     78            }
     79
    6380        }
    6481    }

  • FarmatikoServices/Services/PharmacyService.cs

    r63d885e ree137aa  
    55using System.Collections.Generic;
    66using System.Linq;
    7 using System.Threading.Tasks;
    87
    98namespace FarmatikoServices.Services
    … …  
    1615            _pharmacyRepository = pharmacyRepository;
    1716        }
    18         public async void Add(Pharmacy pharmacy)
     17        public void Add(Pharmacy pharmacy)
    1918        {
    20             if (pharmacy != null)
    21                 await Task.Run(() => _pharmacyRepository.Add(pharmacy));
    22             else throw new Exception("Can't add, pharmacy has null value.");
     19            try
     20            {
     21                if (pharmacy != null)
     22                {
     23                    _pharmacyRepository.Add(pharmacy);
     24                }
     25            }
     26            catch (Exception e)
     27            {
     28                e = new Exception("Can't add, pharmacy has null value.");
     29                throw e;
     30            }
     31           
    2332        }
    2433
    25         public async Task<IQueryable<Pharmacy>> GetAll()
     34        public IQueryable<Pharmacy> GetAll()
    2635        {
    27             return await Task.Run(() => _pharmacyRepository.GetAll());
     36            return _pharmacyRepository.GetAll();
    2837        }
    2938
    30         public async Task<ICollection<Pharmacy>> GetPharmacies()
     39        public ICollection<Pharmacy> GetPharmacies()
    3140        {
    32             return await Task.Run(() => _pharmacyRepository.GetPharmacies());
     41            return _pharmacyRepository.GetPharmacies();
    3342        }
    3443
    35         public async void Remove(Pharmacy pharmacy)
     44        public void Remove(Pharmacy pharmacy)
    3645        {
    37             if (pharmacy != null)
    38                 await Task.Run(() => _pharmacyRepository.Remove(pharmacy));
    39             else throw new Exception("Can't remove, pharmacy has null value.");
     46            try
     47            {
     48                if (pharmacy != null)
     49                    _pharmacyRepository.Remove(pharmacy);
     50            }
     51            catch (Exception e)
     52            {
     53                e = new Exception("Can't remove, pharmacy has null value.");
     54                throw e;
     55            }
    4056        }
    4157
    42         public async void UpdatePharmacy(Pharmacy pharmacy)
     58        public void UpdatePharmacy(Pharmacy pharmacy, string Name)
    4359        {
    44             if (pharmacy != null)
    45                 await Task.Run(() => _pharmacyRepository.UpdatePharmacy(pharmacy));
    46             else throw new Exception("Can not update pharmacy, has null value.");
     60            try
     61            {
     62                if (pharmacy != null && Name != null)
     63                {
     64                    _pharmacyRepository.UpdatePharmacy(pharmacy, Name);
     65                }
     66            }
     67            catch (Exception e)
     68            {
     69                e = new Exception("Can not update pharmacy, has null value.");
     70                throw e;
     71            }
     72           
    4773        }
    4874    }

  • FarmatikoServices/Services/ProcessJSONService.cs

    r63d885e ree137aa  
    1010using FarmatikoServices.FarmatikoServiceInterfaces;
    1111using RestSharp;
    12 using System.Threading.Tasks;
    1312
    1413namespace FarmatikoServices.Services
    … …  
    1615    public class ProcessJSONService : IProcessJSONService
    1716    {
    18         private IHealthFacilityRepository _healthFacilityRepository;
     17        //private IHealthFacilityRepository _healthFacilityRepository;
    1918        private IPandemicRepository _pandemicRepository;
    20         private IHealthcareWorkerRepository _healthcareWorkerRepository;
    21         private IMedicineRepository _medicineRepository;
    22         private readonly ILogger _logger;
    23         public ProcessJSONService(IHealthFacilityRepository healthFacilityRepository, IPandemicRepository pandemicRepository,
    24             IHealthcareWorkerRepository healthcareWorkerRepository, IMedicineRepository medicineRepository, ILogger logger)
     19        //private IHealthcareWorkerRepository _healthcareWorkerRepository;
     20        //private IMedicineRepository _medicineRepository;
     21        //private readonly ILogger _logger;
     22        public ProcessJSONService(/*IHealthFacilityRepository healthFacilityRepository, */IPandemicRepository pandemicRepository/*,
     23            IHealthcareWorkerRepository healthcareWorkerRepository, IMedicineRepository medicineRepository*/)
    2524        {
    26             _logger = logger;
    27             _healthFacilityRepository = healthFacilityRepository;
     25            //_logger = logger;
     26            //_healthFacilityRepository = healthFacilityRepository;
    2827            _pandemicRepository = pandemicRepository;
    29             _healthcareWorkerRepository = healthcareWorkerRepository;
    30             _medicineRepository = medicineRepository;
     28            //_healthcareWorkerRepository = healthcareWorkerRepository;
     29            //_medicineRepository = medicineRepository;
    3130        }
    32 
    33         public async Task<HashSet<HealthFacilities>> GetProcessedHealthFacilitiesFromJSON()
     31       
     32        public List<HealthFacilities> GetProcessedHealthFacilitiesFromJSON()
    3433        {
    3534            try
    3635            {
    37                 HashSet<HealthFacilities> hashSet = new HashSet<HealthFacilities>();
    38                 var client = new WebClient();
    39                 var json = client.DownloadString(@"C:\Users\dslez\Desktop\ustanovi.json");
     36                /*var client = new WebClient();
     37                var json = client.DownloadString(@"C:\Users\Miki\Desktop\ustanovi.json");
    4038
    4139                var jsonResponse = JObject.Parse(json);
    4240                var records = JArray.Parse(jsonResponse.GetValue("records").ToString());
    4341
    44                 foreach (var rec in records)
     42                foreach(var rec in records)
    4543                {
    4644                    dynamic obj = JsonConvert.DeserializeObject(rec.ToString());
    … …  
    5149                    var Phone = obj[11];
    5250                    var Type = obj[5];
    53                     HealthFacilities healthFacility = new HealthFacilities(Name, Municipality, Address, Type, Email, Phone);
    54                     /*healthFacility.Name = Name;
     51                    HealthFacilities healthFacility = new HealthFacilities();
     52                    healthFacility.Name = Name;
    5553                    healthFacility.Municipality = Municipality;
    5654                    healthFacility.Address = Address;
    5755                    healthFacility.Email = Email;
    5856                    healthFacility.Phone = Phone;
    59                     healthFacility.Type = Type;*/
    60                     //hashSet.Add(healthFacility);
    61                     await Task.Run(() => _healthFacilityRepository.Add(healthFacility));
     57                    healthFacility.Type = Type;
     58                    _healthFacilityRepository.Add(healthFacility);
     59                   
     60                }*/
    6261
    63                 }
    6462
    65             }
    66             catch (Exception e)
    67             {
    68                 _logger.LogInformation(e.Message);
    69                 throw new Exception("Cannot process health facilities from JSON.");
    70             }
    71             return null;
    72         }
    7363
    74         public async Task<HashSet<Pandemic>> GetProcessedPandemicsFromJSONApi()
    75         {
    76             try
    77             {
    78                 var client = new RestClient("https://api.covid19api.com/summary");
    79                 var response = client.Execute(new RestRequest());
     64                var client1 = new RestClient("https://api.covid19api.com/summary");
     65                var response = client1.Execute(new RestRequest());
    8066                string original = response.Content;
    8167                var jsonResponsePandemic = JObject.Parse(original);
    … …  
    9278                var NewMK = Int32.Parse(objP.GetValue("NewConfirmed").ToString());
    9379
    94                 var Name = "Coronavirus";
    95                 var ActiveMk = TotalMk - (TotalRecoveredMK + TotalDeathsMK);
    96                 var ActiveGlobal = TotalConfirmed - (TotalRecovered + TotalDeaths);
    97 
    98                 Pandemic pandemic = new Pandemic(Name, TotalMk, ActiveMk, TotalDeathsMK, NewMK, TotalConfirmed, TotalDeaths, ActiveGlobal);
    99                 /*pandemic.TotalGlobal = TotalConfirmed;
     80                Pandemic pandemic = new Pandemic();
     81                pandemic.TotalGlobal = TotalConfirmed;
    10082                pandemic.ActiveGlobal = TotalConfirmed - (TotalRecovered + TotalDeaths);
    10183                pandemic.DeathsGlobal = TotalDeaths;
    … …  
    10486                pandemic.DeathsMK = TotalDeathsMK;
    10587                pandemic.NewMK = NewMK;
    106                 pandemic.Name = "Coronavirus";*/
    107                 await Task.Run(() => _pandemicRepository.Add(pandemic));
    108             }
    109             catch (Exception e)
    110             {
    111                 _logger.LogInformation(e.Message);
    112             }
    113             return null;
    114         }
     88                pandemic.Name = "Coronavirus";
     89                _pandemicRepository.Add(pandemic);
    11590
    116         public async Task<HashSet<HealthcareWorkers>> GetProcessedHealthcareWorkersFromJSON()
    117         {
    118             try
    119             {
    120                 var client = new WebClient();
    121                 var jsonW = client.DownloadString(@"C:\Users\dslez\Desktop\rabotnici.json");
     91
     92
     93                /*var jsonW = client.DownloadString(@"C:\Users\Miki\Desktop\rabotnici.json");
    12294
    12395                var jsonResponseW = JObject.Parse(jsonW);
    … …  
    129101                    var Name = obj[4];
    130102                    var Branch = obj[2];
    131                     var FacilityName = obj[1];
     103                    HealthFacilities facility = new HealthFacilities();
     104                    facility.Name = obj[1];
     105                    facility.Municipality = "WorkerFacilityMunicipality";
     106                    facility.Address = "WorkerFacilityAddress";
    132107                    var Title = obj[3];
    133                     HealthFacilities facility = _healthFacilityRepository.GetByName(FacilityName);
    134                     HealthFacilities Facility = new HealthFacilities(facility.Name, facility.Municipality, facility.Address,
    135                                                                         facility.Type, facility.Email, facility.Phone);
    136                     HealthcareWorkers healthcareWorker = new HealthcareWorkers(Name, Branch, Facility, Title);
    137                     /*Facility.Name = obj[1];
    138                     Facility.Municipality = "WorkerFacilityMunicipality";
    139                     Facility.Address = "WorkerFacilityAddress";*/
    140                     /*healthcareWorker.Name = Name;
     108                    HealthcareWorkers healthcareWorker = new HealthcareWorkers();
     109                    healthcareWorker.Name = Name;
    141110                    healthcareWorker.Branch = Branch;
    142                     healthcareWorker.Facility = Facility;
    143                     healthcareWorker.Title = Title;*/
    144                     await Task.Run(() => _healthcareWorkerRepository.Add(healthcareWorker));
     111                    healthcareWorker.Facility = facility;
     112                    healthcareWorker.Title = Title;
     113                    _healthcareWorkerRepository.Add(healthcareWorker);
    145114                }
    146             }
    147             catch (Exception e)
    148             {
    149                 _logger.LogInformation(e.Message);
    150             }
    151             return null;
    152         }
    153115
    154         public async Task<HashSet<Medicine>> GetProcessedMedicinesFromJSON()
    155         {
    156             try
    157             {
    158                 var client = new WebClient();
    159                 var jsonM = client.DownloadString(@"C:\Users\dslez\Desktop\lekovi.json");
     116
     117
     118                var jsonM = client.DownloadString(@"C:\Users\Miki\Desktop\lekovi.json");
    160119
    161120                var jsonResponseM = JObject.Parse(jsonM);
    … …  
    172131                    var Price = float.Parse(obj[17]);
    173132                    var Packaging = obj[8];
    174                     Medicine medicine = new Medicine(Name, Strength, Form, WayOfIssuing, Manufacturer, Price, Packaging);
    175                     /*medicine.Name = Name;
     133                    Medicine medicine = new Medicine();
     134                    medicine.Name = Name;
    176135                    medicine.Strength = Strength;
    177136                    medicine.Form = Form;
    … …  
    179138                    medicine.Manufacturer = Manufacturer;
    180139                    medicine.Price = Price;
    181                     medicine.Packaging = Packaging;*/
    182                     await Task.Run(() => _medicineRepository.Add(medicine));
    183                 }
     140                    medicine.Packaging = Packaging;
     141                    _medicineRepository.Add(medicine);
     142                }*/
     143
     144
    184145            }
    185146            catch (Exception e)
    186147            {
    187                 _logger.LogInformation(e.Message);
     148                //_logger.LogError(e.Message);
     149                Console.WriteLine(e.Message);
     150                throw e;
     151                return null;
    188152            }
    189153            return null;
    190154        }
     155
    191156    }
    192157}
Note: See TracChangeset for help on using the changeset viewer.