Changeset 6f203af


Ignore:
Timestamp:
10/28/20 22:06:48 (22 months ago)
Author:
DimitarSlezenkovski <dslezenkovski@…>
Branches:
master
Children:
993189e
Parents:
1454207
Message:

Change methods & add error controller

Files:
1 added
19 edited

Legend:

Unmodified
Added
Removed
  • Farmatiko/ClientApp/src/app/shared/data.service.ts

    r1454207 r6f203af  
    160160    //PharmacyHead POST
    161161    insertPharmacyHead(head: IPharmacyHead) : Observable<IPharmacyHead> {
    162         return this.http.post<IPharmacyHead>(this.basePharmacyHead, head)
     162        return this.http.post<IPharmacyHead>(this.basePharmacyHead + '/add', head)
    163163                   .pipe(
    164164                        map((data) => {
     
    189189    //PharmacyHead DELETE
    190190    deletePharmacyHead(id: string) : Observable<boolean> {
    191         return this.http.delete<boolean>(this.basePharmacyHead + '/' + id)
     191        return this.http.delete<boolean>(this.basePharmacyHead + '/delete/' + id)
    192192                   .pipe(catchError(this.handleError));
    193193    }
  • Farmatiko/Controllers/AdminController.cs

    r1454207 r6f203af  
    2323        //GET
    2424        [HttpGet]
    25         public async Task<IQueryable<PharmacyHead>> GetPharmacyHeads()
     25        [Route("api/pharmacyhead")]
     26        public async Task<IEnumerable<PharmacyHead>> GetPharmacyHeads()
    2627        {
    2728            return await _adminService.GetPharmacyHeads();
     
    2930
    3031        [HttpGet]
    31         public async Task<IQueryable<RequestPharmacyHead>> GetClaimingRequests()
     32        [Route("api/pharmacyhead/requests")]
     33        public async Task<IEnumerable<RequestPharmacyHead>> GetClaimingRequests()
    3234        {
    33             return await _adminService.GetCalimingRequests();
     35            return await _adminService.GetClaimingRequests();
    3436        }
    3537
     
    3739        //POST
    3840        [HttpPost]
     41        [Route("api/pharmacyhead/add")]
    3942        public async Task<IActionResult> AddPharmacyHead(PharmacyHead pharmacyHead)
    4043        {
     
    4447
    4548        [HttpPost]
    46         public async Task<IActionResult> RemovePharmacyHead(PharmacyHead pharmacyHead)
     49        [Route("api/pharmacyhead/delete/{Id}")]
     50        public async Task<IActionResult> RemovePharmacyHead([FromQuery]int Id)
    4751        {
    48             await _service.RemovePharmacyHead(pharmacyHead);
     52            await _service.RemovePharmacyHead(Id);
    4953            return Ok();
    5054        }
    5155        [HttpPost]
    52         public async Task<IActionResult> RejectRequset(RequestPharmacyHead req)
     56        public IActionResult RejectRequset(RequestPharmacyHead req)
    5357        {
    54             await _adminService.RejectRequest(req);
    55             return Ok();
     58            bool Success = _adminService.RejectRequest(req);
     59            return Ok(Success);
    5660        }
    5761        [HttpPost]
  • Farmatiko/Controllers/FarmatikoController.cs

    r1454207 r6f203af  
    1 using System.Linq;
     1using System.Collections.Generic;
    22using System.Threading.Tasks;
    33using FarmatikoData.Models;
     
    88{
    99    [ApiController]
    10     [Route("api/[action]")]
    1110    public class FarmatikoController : Controller
    1211    {
     
    1918        //Get
    2019        [HttpGet]
    21         [Route("/api/workers")]
    22         public async Task<IQueryable<HealthcareWorker>> GetWorkers()
     20        [Route("api/workers")]
     21        public async Task<IEnumerable<HealthcareWorker>> GetWorkers()
    2322        {
    2423            var Workers =  await _service.GetAllWorkers();
     
    2625        }
    2726        [HttpGet]
    28         [Route("/api/workers/search/{Query}")]
    29         public async Task<IQueryable<HealthcareWorker>> SearchWorkers(string Query)
     27        [Route("api/workers/search/{Query}")]
     28        public async Task<IEnumerable<HealthcareWorker>> SearchWorkers(string Query)
    3029        {
    3130            return await _service.SearchWorkers(Query);
    3231        }
    3332        [HttpGet]
    34         [Route("/api/workers/{id}")]
     33        [Route("api/workers/{id}")]
    3534        public async Task<HealthcareWorker> GetWorker(int Id)
    3635        {
     
    4342        //Get
    4443        [HttpGet]
    45         [Route("/api/facilities")]
    46         public async Task<IQueryable<HealthFacility>> GetFacilities()
     44        [Route("api/facilities")]
     45        public async Task<IEnumerable<HealthFacility>> GetFacilities()
    4746        {
    4847            return await _service.GetFacilities();
    4948        }
    5049        [HttpGet]
    51         [Route("/api/facilities/search/{Query}")]
    52         public async Task<IQueryable<HealthFacility>> SearchFacilities(string Query)
     50        [Route("api/facilities/search/{Query}")]
     51        public async Task<IEnumerable<HealthFacility>> SearchFacilities(string Query)
    5352        {
    5453            return await _service.SearchFacilities(Query);
    5554        }
    5655        [HttpGet]
    57         [Route("/api/facilities/{Id}")]
     56        [Route("api/facilities/{Id}")]
    5857        public async Task<HealthFacility> GetFacility(int Id)
    5958        {
     
    6564        //Get
    6665        [HttpGet]
    67         [Route("/api/medicines")]
    68         public async Task<IQueryable<Medicine>> GetMedicines()
     66        [Route("api/medicines")]
     67        public async Task<IEnumerable<Medicine>> GetMedicines()
    6968        {
    7069            return await _service.GetMedicines();
    7170        }
    7271        [HttpGet]
    73         [Route("/api/medicines/search/{Query}")]
    74         public async Task<IQueryable<Medicine>> SearchMedicines(string Query)
     72        [Route("api/medicines/search/{Query}")]
     73        public async Task<IEnumerable<Medicine>> SearchMedicines(string Query)
    7574        {
    7675            return await _service.SearchMedicines(Query);
    7776        }
    7877        [HttpGet]
    79         [Route("/api/medicines/{Id}")]
     78        [Route("api/medicines/{Id}")]
    8079        public async Task<Medicine> GetMedicine(int Id)
    8180        {
    8281            return await _service.GetMedicine(Id);
    8382        }
    84         //POST
    85 
    8683        //Pandemic
    8784        [HttpGet]
    88         [Route("/api/pandemic")]
     85        [Route("api/pandemic")]
    8986        public async Task<Pandemic> GetPandemic()
    9087        {
     
    9491        //GET
    9592        [HttpGet]
    96         [Route("/api/pharmacy")]
    97         public async Task<IQueryable<Pharmacy>> GetPharmacies()
     93        [Route("api/pharmacy")]
     94        public async Task<IEnumerable<Pharmacy>> GetPharmacies()
    9895        {
    9996            return await _service.GetPharmacies();
    10097        }
    10198        [HttpGet]
    102         [Route("/api/pharmacy/search/{Query}")]
    103         public async Task<IQueryable<Pharmacy>> SearchPharmacies(string Query)
     99        [Route("api/pharmacy/search/{Query}")]
     100        public async Task<IEnumerable<Pharmacy>> SearchPharmacies(string Query)
    104101        {
    105102            return await _service.SearchPharmacies(Query);
    106103        }
    107104        [HttpGet]
    108         [Route("/api/pharmacy/{Id}")]
     105        [Route("api/pharmacy/{Id}")]
    109106        public async Task<Pharmacy> GetPharmacy(int Id)
    110107        {
  • Farmatiko/Controllers/PharmacyHeadController.cs

    r1454207 r6f203af  
    1 using System.Linq;
     1using System.Collections;
     2using System.Collections.Generic;
     3using System.Linq;
    24using System.Threading.Tasks;
    35using FarmatikoData.FarmatikoRepoInterfaces;
     
    911{
    1012    [ApiController]
    11     [Route("api/[action]")]
    1213    public class PharmacyHeadController : Controller
    1314    {
     
    1718            _PHService = PHService;
    1819        }
    19        
     20
    2021        //GET
    2122        //Mi trebaat rutite
    2223        [HttpGet]
    23         public async Task<IQueryable<PharmacyHead>> GetPharmacyHeadInfo(string Token)
     24        [Route("api/pharmacyhead")]
     25        public async Task<IEnumerable<PharmacyHead>> GetPharmacyHeadInfo(string Token)
    2426        {
    25             return await _PHService.GetPharmacyHeadInfo(Token);
     27            var PHeads = await _PHService.GetPharmacyHeadInfo(Token);
     28            return PHeads;
     29        }
     30        [HttpGet]
     31        [Route("api/pharmacyhead/{Id}")]
     32        public async Task<PharmacyHead> GetPharmacyHeadById(int Id)
     33        {
     34            var Phead = await _PHService.GetPharmacyHeadByIdAsync(Id);
     35            return Phead;
    2636        }
    2737        //POST
    2838        [HttpPost]
    29         public async Task<int> Login(PharmacyHead pharmacyHead)
     39        [Route("api/pharmacyhead/add")]
     40        public async Task<IActionResult> AddPharmacyHead(PharmacyHead pharmacyHead)
     41        {
     42            bool Success = await _PHService.Add(pharmacyHead);
     43            return Ok(Success);
     44        }
     45
     46        [HttpPost]
     47        [Route("api/pharmacyhead/login")]
     48        public async Task<int> Login([FromBody]PharmacyHead pharmacyHead)
    3049        {
    3150            return await _PHService.Login(pharmacyHead);
    3251        }
    33         [HttpPost]
    34         public async Task UpdatePharmacyHead(PharmacyHead pharmacyHead)
     52        [HttpPut]
     53        [Route("api/pharmacyhead/{Id}")]
     54        public async Task UpdatePharmacyHead([FromBody]PharmacyHead pharmacyHead)
    3555        {
    3656            await _PHService.UpdatePharmacyHead(pharmacyHead);
    3757        }
    3858        [HttpPost]
     59        [Route("api/pharmacyhead/requests")]
    3960        public async Task<IActionResult> ClaimPharmacy(RequestPharmacyHead pharmacy)
    4061        {
    41             await _PHService.ClaimPharmacy(pharmacy);
    42             return Ok();
     62            bool Success = await _PHService.ClaimPharmacy(pharmacy);
     63            return Ok(Success);
     64        }
     65        [HttpDelete]
     66        [Route("api/pharmacyhead/delete/{Id}")]
     67        public async Task<IActionResult> Remove([FromQuery] int Id)
     68        {
     69            bool Success = await _PHService.Remove(Id);
     70            return Ok(Success);
     71        }
     72        [HttpPost]
     73        [Route("api/pharmacyhead/requests/{Id}")]
     74        public async Task<IActionResult> RemoveClaimingRequest([FromQuery] int Id)
     75        {
     76            bool Success = await _PHService.RemoveClaimingRequest(Id);
     77            return Ok(Success);
    4378        }
    4479       
  • Farmatiko/Startup.cs

    r1454207 r6f203af  
    4848            services.AddEntityFrameworkNpgsql().AddDbContext<FarmatikoDataContext>(opt => opt.UseNpgsql(connectionString));
    4949
    50             services.AddTransient<IHealthFacilityRepository, HealthFacilityRepository>();
    51             services.AddTransient<IHealthFacilityService, HealthFacilityService>();
     50            services.AddTransient<IPHRepo, PHRepo>();
     51            services.AddTransient<IRepository, Repository>();
     52            services.AddTransient<IAdminRepo, AdminRepo>();
    5253
    53             services.AddTransient<IHealthcareWorkerRepository, HealthcareWorkerRepository>();
    54             services.AddTransient<IHealthcareWorkerService, HealthcareWorkerService>();
    55 
    56             services.AddTransient<IMedicineRepository, MedicineRepository>();
    57             services.AddTransient<IMedicineService, MedicineService>();
    58 
    59             services.AddTransient<IMedicineListRepository, MedicineListRepository>();
    60             services.AddTransient<IMedicineListService, MedicineListService>();
    61 
    62             services.AddTransient<IPandemicRepository, PandemicRepository>();
    63             services.AddTransient<IPandemicService, PandemicService>();
    64 
    65             services.AddTransient<IPharmacyHeadRepository, PharmacyHeadRepository>();
    66             services.AddTransient<IPharmacyHeadService, PharmacyHeadService>();
    67 
    68             services.AddTransient<IPharmacyRepository, PharmacyRepository>();
    69             services.AddTransient<IPharmacyService, PharmacyService>();
     54            services.AddTransient<IPHService, PHService>();
     55            services.AddTransient<IAdminService, AdminService>();
     56            services.AddTransient<IService, Service>();
    7057
    7158            services.AddTransient<IProcessJSONService, ProcessJSONService>();
  • FarmatikoData/FarmatikoRepo/AdminRepo.cs

    r1454207 r6f203af  
    11using FarmatikoData.FarmatikoRepoInterfaces;
    22using FarmatikoData.Models;
     3using Microsoft.EntityFrameworkCore;
    34using System;
    45using System.Collections.Generic;
     
    1718        }
    1819
    19         public async Task<IQueryable<RequestPharmacyHead>> GetClaimingRequests()
     20        public async Task<IEnumerable<RequestPharmacyHead>> GetClaimingRequests()
    2021        {
    21             var reqs = await Task.Run(() => _context.PHRequests.OrderBy(x => x.Head.Name));
     22            var reqs = await _context.PHRequests.OrderBy(x => x.Head.Name).ToListAsync();
    2223            return reqs;
    2324        }
    2425
    2526        //GET
    26         public async Task<IQueryable<PharmacyHead>> GetPharmacyHeads()
     27        public async Task<IEnumerable<PharmacyHead>> GetPharmacyHeads()
    2728        {
    28             var PHeads = await Task.Run(() => _context.PharmacyHeads.OrderBy(x => x.Name));
     29            var PHeads = await _context.PharmacyHeads.OrderBy(x => x.Name).ToListAsync();
    2930            return PHeads;
    3031        }
    3132        //POST
    32         public async Task RemoveClaimRequest(RequestPharmacyHead req)
     33        public void RemoveClaimRequest(RequestPharmacyHead req)
    3334        {
    34             await Task.Run(() => _context.PHRequests.Remove(req));
    35             await _context.SaveChangesAsync();
     35            _context.PHRequests.Remove(req);
     36            _context.SaveChanges();
    3637        }
    3738    }
  • FarmatikoData/FarmatikoRepo/PHRepo.cs

    r1454207 r6f203af  
    11using FarmatikoData.FarmatikoRepoInterfaces;
    22using FarmatikoData.Models;
    3 using System;
     3using Microsoft.EntityFrameworkCore;
    44using System.Collections.Generic;
    55using System.Linq;
    6 using System.Text;
    76using System.Threading.Tasks;
    87
     
    1615            _context = context;
    1716        }
    18 
    19         public async Task ClaimPharmacy(RequestPharmacyHead pharmacy)
     17        //GET
     18        public async Task<PharmacyHead> GetPharmacyHeadByIdAsync(int id)
    2019        {
    21             await Task.Run(() => _context.PHRequests.Add(pharmacy));
    22             await _context.SaveChangesAsync();
    23         }
    24 
    25         public async Task<PharmacyHead> GetPharmacyHead(PharmacyHead pharmacyHead)
    26         {
    27             var Phead = await Task.Run(() => _context.PharmacyHeads.Where(x => x.Email.Equals(pharmacyHead.Email)).FirstOrDefault());
     20            var Phead = await _context.PharmacyHeads.Where(x => x.Id == id).FirstOrDefaultAsync();
    2821            return Phead;
    2922        }
    3023
    31         public async Task<IQueryable<PharmacyHead>> GetPharmacyHeadInfo()
     24        public async Task<IEnumerable<PharmacyHead>> GetPharmacyHeadInfo()
    3225        {
    33             var PHeadInfo = await Task.Run(() => _context.PharmacyHeads.Take(10));
     26            var PHeadInfo = await _context.PharmacyHeads.Take(10).Where(x => x.DeletedOn == null)
     27                .Select(x => new PharmacyHead
     28                {
     29                    Id = x.Id,
     30                    Name = x.Name,
     31                    Email = x.Email,
     32                    Password = x.Password,
     33                    MedicineLists = x.MedicineLists,
     34                    PharmaciesList = x.PharmaciesList
     35                }).ToListAsync();
    3436            return PHeadInfo;
    3537        }
    36 
     38        //POST
    3739        public async Task UpdatePharmacyHead(PharmacyHead pharmacyHead)
    3840        {
    39             var EditedPHead = await Task.Run(() => _context.PharmacyHeads.Where(x => x.Id == pharmacyHead.Id).FirstOrDefault());
     41            var EditedPHead = await _context.PharmacyHeads.Where(x => x.Id == pharmacyHead.Id).FirstOrDefaultAsync();
    4042            EditedPHead.Email = pharmacyHead.Email;
    4143            EditedPHead.Name = pharmacyHead.Name;
     
    4547            await _context.SaveChangesAsync();
    4648        }
     49        public async Task ClaimPharmacy(RequestPharmacyHead pharmacy)
     50        {
     51            await _context.PHRequests.AddAsync(pharmacy);
     52            await _context.SaveChangesAsync();
     53        }
     54        public async Task Add(PharmacyHead pharmacyHead)
     55        {
     56            await _context.PharmacyHeads.AddAsync(pharmacyHead);
     57            await _context.SaveChangesAsync();
     58        }
     59
     60        public async Task Remove(PharmacyHead phead)
     61        {
     62            var Phead = await _context.PharmacyHeads.Where(x => x.Id == phead.Id).FirstOrDefaultAsync();
     63            Phead.DeletedOn = phead.DeletedOn;
     64            await _context.SaveChangesAsync();
     65        }
     66
     67        public async Task RemoveClaimingRequest(int id)
     68        {
     69            var req = await _context.PHRequests.Where(r => r.Id == id).FirstOrDefaultAsync();
     70            _context.PHRequests.Remove(req);
     71            await _context.SaveChangesAsync();
     72        }
    4773    }
    4874}
  • FarmatikoData/FarmatikoRepo/Repository.cs

    r1454207 r6f203af  
    11using FarmatikoData.FarmatikoRepoInterfaces;
    22using FarmatikoData.Models;
     3using Microsoft.EntityFrameworkCore;
     4using System;
     5using System.Collections.Generic;
    36using System.Linq;
    47using System.Threading.Tasks;
     
    1417        }
    1518        //GET
    16         public async Task<IQueryable<HealthcareWorker>> GetAllWorkers()
     19        public async Task<IEnumerable<HealthcareWorker>> GetAllWorkers()
    1720        {
    1821            var Workers = await Task.Run(() => _context.HealthcareWorkers.Take(10));
     
    2023        }
    2124
    22         public async Task<IQueryable<HealthFacility>> GetFacilities()
     25        public async Task<IEnumerable<HealthFacility>> GetFacilities()
    2326        {
    2427            var Facilities = await Task.Run(() => _context.HealthFacilities.Take(10));
     
    3841        }
    3942
    40         public async Task<IQueryable<Medicine>> GetMedicines()
     43        public async Task<IEnumerable<Medicine>> GetMedicines()
    4144        {
    4245            var Medicines = await Task.Run(() => _context.Medicines.Take(10));
     
    5053        }
    5154
    52         public async Task<IQueryable<Pharmacy>> GetPharmacies()
     55        public async Task<IEnumerable<Pharmacy>> GetPharmacies()
    5356        {
    5457            var Pharmacies = await Task.Run(() => _context.Pharmacies.Take(10));
     
    6871        }
    6972
    70         public async Task<IQueryable<HealthFacility>> SearchFacilities(string query)
     73        public async Task<IEnumerable<HealthFacility>> SearchFacilities(string query)
    7174        {
    7275            var SearchQuery = await Task.Run(() => _context.HealthFacilities
     
    7780        }
    7881
    79         public async Task<IQueryable<Medicine>> SearchMedicines(string query)
     82        public async Task<IEnumerable<Medicine>> SearchMedicines(string query)
    8083        {
    8184            var SearchQuery = await Task.Run(() => _context.Medicines
     
    8689        }
    8790
    88         public async Task<IQueryable<Pharmacy>> SearchPharmacies(string query)
     91        public async Task<IEnumerable<Pharmacy>> SearchPharmacies(string query)
    8992        {
    9093            var SearchQuery = await Task.Run(() => _context.Pharmacies
     
    9598        }
    9699
    97         public async Task<IQueryable<HealthcareWorker>> SearchWorkers(string query)
     100        public async Task<IEnumerable<HealthcareWorker>> SearchWorkers(string query)
    98101        {
    99102            var SearchQuery = await Task.Run(() => _context.HealthcareWorkers
     
    184187            await _context.SaveChangesAsync();
    185188        }
    186         //ke vidime
     189        //not impl
    187190        public Task UpdateWorker(HealthcareWorker worker)
    188191        {
     
    205208        }
    206209
    207         public async Task RemovePharmacyHead(PharmacyHead pharmacyHead)
    208         {
    209             var PHead = await Task.Run(() => _context.PharmacyHeads.Where(x => x.Id == pharmacyHead.Id).FirstOrDefault());
    210             PHead.DeletedOn = pharmacyHead.DeletedOn;
     210        public async Task RemovePharmacyHead(int Id)
     211        {
     212            var PHead = await _context.PharmacyHeads.Where(x => x.Id == Id).FirstOrDefaultAsync();
     213            PHead.DeletedOn = DateTime.UtcNow;
    211214            await _context.SaveChangesAsync();
    212215        }
  • FarmatikoData/FarmatikoRepoInterfaces/IAdminRepo.cs

    r1454207 r6f203af  
    1010    public interface IAdminRepo
    1111    {
    12         Task<IQueryable<RequestPharmacyHead>> GetClaimingRequests();
    13         Task<IQueryable<PharmacyHead>> GetPharmacyHeads();
    14         Task RemoveClaimRequest(RequestPharmacyHead req);
     12        Task<IEnumerable<RequestPharmacyHead>> GetClaimingRequests();
     13        Task<IEnumerable<PharmacyHead>> GetPharmacyHeads();
     14        void RemoveClaimRequest(RequestPharmacyHead req);
    1515    }
    1616}
  • FarmatikoData/FarmatikoRepoInterfaces/IPHRepo.cs

    r1454207 r6f203af  
    1111    {
    1212        Task ClaimPharmacy(RequestPharmacyHead pharmacy);
    13         Task<PharmacyHead> GetPharmacyHead(PharmacyHead pharmacyHead);
    14         Task<IQueryable<PharmacyHead>> GetPharmacyHeadInfo();
     13        Task<IEnumerable<PharmacyHead>> GetPharmacyHeadInfo();
    1514        Task UpdatePharmacyHead(PharmacyHead pharmacyHead);
     15        Task<PharmacyHead> GetPharmacyHeadByIdAsync(int id);
     16        Task Add(PharmacyHead pharmacyHead);
     17        Task Remove(PharmacyHead phead);
     18        Task RemoveClaimingRequest(int id);
    1619    }
    1720}
  • FarmatikoData/FarmatikoRepoInterfaces/IRepository.cs

    r1454207 r6f203af  
    1111    {
    1212        //GET
    13         Task<IQueryable<HealthcareWorker>> GetAllWorkers();
    14         Task<IQueryable<HealthFacility>> GetFacilities();
     13        Task<IEnumerable<HealthcareWorker>> GetAllWorkers();
     14        Task<IEnumerable<HealthFacility>> GetFacilities();
    1515        Task<HealthFacility> GetFacility(int Id);
    1616        Task<Medicine> GetMedicine(int Id);
    17         Task<IQueryable<Medicine>> GetMedicines();
     17        Task<IEnumerable<Medicine>> GetMedicines();
    1818        Task<Pandemic> GetPandemic();
    19         Task<IQueryable<Pharmacy>> GetPharmacies();
     19        Task<IEnumerable<Pharmacy>> GetPharmacies();
    2020        Task<Pharmacy> GetPharmacy(int id);
    2121        Task<HealthcareWorker> GetWorker(int id);
    22         Task<IQueryable<HealthFacility>> SearchFacilities(string query);
    23         Task<IQueryable<Medicine>> SearchMedicines(string query);
    24         Task<IQueryable<Pharmacy>> SearchPharmacies(string query);
    25         Task<IQueryable<HealthcareWorker>> SearchWorkers(string query);
     22        Task<IEnumerable<HealthFacility>> SearchFacilities(string query);
     23        Task<IEnumerable<Medicine>> SearchMedicines(string query);
     24        Task<IEnumerable<Pharmacy>> SearchPharmacies(string query);
     25        Task<IEnumerable<HealthcareWorker>> SearchWorkers(string query);
    2626        Task<HealthFacility> GetFacilityJSON(string healthFacility);
    2727
     
    4040        Task UpadatePharmacy(Pharmacy pharmacy);
    4141        Task UpdateMedicine(Medicine medicine);
    42         Task RemovePharmacyHead(PharmacyHead pharmacyHead);
     42        Task RemovePharmacyHead(int Id);
    4343    }
    4444}
  • FarmatikoServices/FarmatikoServiceInterfaces/IAdminService.cs

    r1454207 r6f203af  
    1010    public interface IAdminService
    1111    {
    12         Task<IQueryable<PharmacyHead>> GetPharmacyHeads();
    13         Task<IQueryable<RequestPharmacyHead>> GetCalimingRequests();
    14         Task RejectRequest(RequestPharmacyHead req);
     12        Task<IEnumerable<PharmacyHead>> GetPharmacyHeads();
     13        Task<IEnumerable<RequestPharmacyHead>> GetClaimingRequests();
     14        bool RejectRequest(RequestPharmacyHead req);
    1515    }
    1616}
  • FarmatikoServices/FarmatikoServiceInterfaces/IPHService.cs

    r1454207 r6f203af  
    1010    public interface IPHService
    1111    {
    12         Task<IQueryable<PharmacyHead>> GetPharmacyHeadInfo(string Token);
     12        Task<IEnumerable<PharmacyHead>> GetPharmacyHeadInfo(string Token);
    1313        Task UpdatePharmacyHead(PharmacyHead pharmacyHead);
    1414        Task<int> Login(PharmacyHead pharmacyHead);
    15         Task ClaimPharmacy(RequestPharmacyHead pharmacy);
     15        Task<bool> ClaimPharmacy(RequestPharmacyHead pharmacy);
     16        Task<PharmacyHead> GetPharmacyHeadByIdAsync(int id);
     17        Task<bool> Add(PharmacyHead pharmacyHead);
     18        Task<bool> Remove(int id);
     19        Task<bool> RemoveClaimingRequest(int id);
    1620    }
    1721}
  • FarmatikoServices/FarmatikoServiceInterfaces/IService.cs

    r1454207 r6f203af  
    11using FarmatikoData.Models;
     2using System.Collections.Generic;
    23using System.Linq;
    34using System.Threading.Tasks;
     
    89    {
    910        //GET
    10         Task<IQueryable<HealthcareWorker>> GetAllWorkers();
    11         Task<IQueryable<HealthcareWorker>> SearchWorkers(string query);
     11        Task<IEnumerable<HealthcareWorker>> GetAllWorkers();
     12        Task<IEnumerable<HealthcareWorker>> SearchWorkers(string query);
    1213        Task<HealthcareWorker> GetWorker(int id);
    13         Task<IQueryable<HealthFacility>> GetFacilities();
    14         Task<IQueryable<HealthFacility>> SearchFacilities(string query);
     14        Task<IEnumerable<HealthFacility>> GetFacilities();
     15        Task<IEnumerable<HealthFacility>> SearchFacilities(string query);
    1516        Task<HealthFacility> GetFacility(int id);
    1617        Task<HealthFacility> GetFacilityJSON(string healthFacility);
    1718        Task<Medicine> GetMedicine(int id);
    18         Task<IQueryable<Medicine>> SearchMedicines(string query);
    19         Task<IQueryable<Medicine>> GetMedicines();
     19        Task<IEnumerable<Medicine>> SearchMedicines(string query);
     20        Task<IEnumerable<Medicine>> GetMedicines();
    2021        Task<Pandemic> GetPandemic();
    21         Task<IQueryable<Pharmacy>> GetPharmacies();
    22         Task<IQueryable<Pharmacy>> SearchPharmacies(string query);
     22        Task<IEnumerable<Pharmacy>> GetPharmacies();
     23        Task<IEnumerable<Pharmacy>> SearchPharmacies(string query);
    2324        Task<Pharmacy> GetPharmacy(int id);
    2425        //POST
     
    3132        Task UpdateFacility(HealthFacility healthFacilities);
    3233        Task RemoveMedicine(Medicine medicine);
    33         Task RemovePharmacyHead(PharmacyHead pharmacyHead);
     34        Task RemovePharmacyHead(int Id);
    3435        Task UpdatePandemic(Pandemic pandemic);
    3536        Task RemovePharmacy(Pharmacy pharmacy);
  • FarmatikoServices/FarmatikoServices.csproj

    r1454207 r6f203af  
    66
    77  <ItemGroup>
     8    <PackageReference Include="EPPlus" Version="5.4.0" />
    89    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
    910    <PackageReference Include="RestSharp" Version="106.11.4" />
  • FarmatikoServices/Services/AdminService.cs

    r1454207 r6f203af  
    55using System.Collections.Generic;
    66using System.Linq;
    7 using System.Text;
    87using System.Threading.Tasks;
    98
     
    1817        }
    1918
    20         public async Task<IQueryable<RequestPharmacyHead>> GetCalimingRequests()
     19        public async Task<IEnumerable<RequestPharmacyHead>> GetClaimingRequests()
    2120        {
    22             var req = await Task.Run(() => _adminRepo.GetClaimingRequests());
    23             return req;
     21            var req = await _adminRepo.GetClaimingRequests();
     22            if (req != null)
     23                return req;
     24            throw new Exception("No data is found.");
    2425        }
    2526
    26         public async Task<IQueryable<PharmacyHead>> GetPharmacyHeads()
     27        public async Task<IEnumerable<PharmacyHead>> GetPharmacyHeads()
    2728        {
    28             var PHeads = await Task.Run(() => _adminRepo.GetPharmacyHeads());
    29             return PHeads;
     29            var PHeads = await _adminRepo.GetPharmacyHeads();
     30            var list = PHeads.Select(x => x.DeletedOn == null);
     31            if (list != null)
     32            {
     33                return PHeads;
     34            }
     35            throw new Exception("No data is found.");
    3036        }
    3137
    32         public async Task RejectRequest(RequestPharmacyHead req)
     38        public bool RejectRequest(RequestPharmacyHead req)
    3339        {
    34             await _adminRepo.RemoveClaimRequest(req);
     40            if (req != null)
     41            {
     42                _adminRepo.RemoveClaimRequest(req);
     43                return true;
     44            }
     45            return false;
    3546        }
    3647    }
  • FarmatikoServices/Services/PHService.cs

    r1454207 r6f203af  
    1818        }
    1919
    20         public async Task ClaimPharmacy(RequestPharmacyHead pharmacy)
     20        public async Task<bool> ClaimPharmacy(RequestPharmacyHead pharmacy)
    2121        {
    22             await _iPHRepo.ClaimPharmacy(pharmacy);
     22            if (pharmacy != null)
     23            {
     24                await _iPHRepo.ClaimPharmacy(pharmacy);
     25                return true;
     26            }
     27            return false;
    2328        }
    2429
    25         public Task<IQueryable<PharmacyHead>> GetPharmacyHeadInfo(string Token)
     30        public async Task<PharmacyHead> GetPharmacyHeadByIdAsync(int id)
    2631        {
    27             throw new NotImplementedException();
     32            PharmacyHead Phead = null;
     33            if (id >= 0)
     34                Phead = await _iPHRepo.GetPharmacyHeadByIdAsync(id);
     35            if (Phead != null)
     36                return Phead;
     37            throw new Exception("No data found.");
     38        }
     39
     40        public async Task<IEnumerable<PharmacyHead>> GetPharmacyHeadInfo(string Token)
     41        {
     42            var PHeads = await _iPHRepo.GetPharmacyHeadInfo();
     43            if (PHeads != null)
     44                return PHeads;
     45            throw new Exception("No Pharmacy heads found.");
    2846        }
    2947
    3048        public async Task<int> Login(PharmacyHead pharmacyHead)
    3149        {
    32             var PHead = await Task.Run(() => _iPHRepo.GetPharmacyHead(pharmacyHead));
     50            var PHead = await _iPHRepo.GetPharmacyHeadByIdAsync(pharmacyHead.Id);
    3351            if (PHead.Password.Equals(pharmacyHead.Password))
    3452                return PHead.Id;
     
    4361            else throw new Exception("PharmacyHead has a null value.");
    4462        }
     63        public async Task<bool> Add(PharmacyHead pharmacyHead)
     64        {
     65            if (pharmacyHead != null)
     66            {
     67                await _iPHRepo.Add(pharmacyHead);
     68                return true;
     69            }
     70            return false;
     71        }
     72
     73        public async Task<bool> Remove(int id)
     74        {
     75            PharmacyHead Phead = await _iPHRepo.GetPharmacyHeadByIdAsync(id);
     76            if (Phead != null && id >= 0)
     77            {
     78                Phead.DeletedOn = DateTime.UtcNow;
     79                await _iPHRepo.Remove(Phead);
     80                return true;
     81            }
     82            return false;
     83        }
     84
     85        public async Task<bool> RemoveClaimingRequest(int id)
     86        {
     87            if (id >= 0)
     88            {
     89                await _iPHRepo.RemoveClaimingRequest(id);
     90                return true;
     91            }
     92            return false;
     93        }
    4594    }
    4695}
  • FarmatikoServices/Services/ProcessJSONService.cs

    r1454207 r6f203af  
    2929        public async Task<Medicine> ReadPharmaciesFromExcel()
    3030        {
    31             var client = new WebClient();
    32             string Path = client.DownloadString(@"C:\Users\dslez\Desktop\apteki-fzo.xlsx");
    33             using (var package = new ExcelPackage(new FileInfo(Path)))
    34             {
    35                 var Sheet = package.Workbook.Worksheets[1];
    36                 for (int i = 2; i < Sheet.Dimension.End.Row; ++i)
    37                 {
    38                     Pharmacy pharmacy = new Pharmacy()
     31            try
     32            {
     33                var client = new WebClient();
     34                string Path = client.DownloadString(@"C:\Users\dslez\Desktop\apteki-fzo.xlsx");
     35                using (var package = new ExcelPackage(new FileInfo(Path)))
     36                {
     37                    var Sheet = package.Workbook.Worksheets[1];
     38                    for (int i = 2; i < Sheet.Dimension.End.Row; ++i)
    3939                    {
    40                         Name = Sheet.Cells[i, 2].Value.ToString(),
    41                         Address = Sheet.Cells[i, 3].Value.ToString(),
    42                         Location = Sheet.Cells[i, 4].Value.ToString(),
    43                         WorkAllTime = false
    44                     };
    45                     await _service.AddPharmacy(pharmacy);
    46                 }
     40                        Pharmacy pharmacy = new Pharmacy()
     41                        {
     42                            Name = Sheet.Cells[i, 2].Value.ToString(),
     43                            Address = Sheet.Cells[i, 3].Value.ToString(),
     44                            Location = Sheet.Cells[i, 4].Value.ToString(),
     45                            WorkAllTime = false
     46                        };
     47                        await _service.AddPharmacy(pharmacy);
     48                    }
     49                }
     50
     51            }
     52            catch(Exception e)
     53            {
     54                _logger.LogInformation(e.Message);
     55                throw new Exception("Cannot process Medicines from Excel.");
    4756            }
    4857            return null;
  • FarmatikoServices/Services/Service.cs

    r1454207 r6f203af  
    33using FarmatikoServices.FarmatikoServiceInterfaces;
    44using System;
     5using System.Collections.Generic;
    56using System.Linq;
    67using System.Threading.Tasks;
     
    1718
    1819        //GET
    19         public async Task<IQueryable<HealthcareWorker>> GetAllWorkers()
     20        public async Task<IEnumerable<HealthcareWorker>> GetAllWorkers()
    2021        {
    2122            var Workers = await _repository.GetAllWorkers();
     
    2324        }
    2425
    25         public async Task<IQueryable<HealthFacility>> GetFacilities()
     26        public async Task<IEnumerable<HealthFacility>> GetFacilities()
    2627        {
    2728            var Facilities = await _repository.GetFacilities();
     
    4142        }
    4243
    43         public async Task<IQueryable<Medicine>> GetMedicines()
     44        public async Task<IEnumerable<Medicine>> GetMedicines()
    4445        {
    4546            var Medicines = await _repository.GetMedicines();
     
    5354        }
    5455
    55         public async Task<IQueryable<Pharmacy>> GetPharmacies()
     56        public async Task<IEnumerable<Pharmacy>> GetPharmacies()
    5657        {
    5758            var Pharmacies = await _repository.GetPharmacies();
     
    7172        }
    7273
    73         public async Task<IQueryable<HealthFacility>> SearchFacilities(string query)
     74        public async Task<IEnumerable<HealthFacility>> SearchFacilities(string query)
    7475        {
    7576            var SearchQuery = await _repository.SearchFacilities(query);
     
    7778        }
    7879
    79         public async Task<IQueryable<Medicine>> SearchMedicines(string query)
     80        public async Task<IEnumerable<Medicine>> SearchMedicines(string query)
    8081        {
    8182            var SearchQuery = await _repository.SearchMedicines(query);
     
    8384        }
    8485
    85         public async Task<IQueryable<Pharmacy>> SearchPharmacies(string query)
     86        public async Task<IEnumerable<Pharmacy>> SearchPharmacies(string query)
    8687        {
    8788            var SearchQuery = await _repository.SearchPharmacies(query);
     
    8990        }
    9091
    91         public async Task<IQueryable<HealthcareWorker>> SearchWorkers(string query)
     92        public async Task<IEnumerable<HealthcareWorker>> SearchWorkers(string query)
    9293        {
    9394            var SearchQuery = await _repository.SearchWorkers(query);
     
    202203        }
    203204
    204         public async Task RemovePharmacyHead(PharmacyHead pharmacyHead)
    205         {
    206             if (pharmacyHead != null)
     205        public async Task RemovePharmacyHead(int Id)
     206        {
     207            if (Id > 0)
    207208            {
    208                 pharmacyHead.DeletedOn = DateTime.UtcNow;
    209                 await _repository.RemovePharmacyHead(pharmacyHead);
     209                await _repository.RemovePharmacyHead(Id);
    210210            }
    211             else throw new Exception("PharmacyHead is null.");
     211            throw new Exception("Index out of bounds.");
    212212        }
    213213
Note: See TracChangeset for help on using the changeset viewer.