Changeset db484c9


Ignore:
Timestamp:
01/26/21 10:33:09 (4 years ago)
Author:
DimitarSlezenkovski <dslezenkovski@…>
Branches:
master
Children:
7d80751
Parents:
8e74e2f
Message:

Fix bugs

Files:
1 added
17 edited
2 moved

Legend:

Unmodified
Added
Removed

  • Farmatiko/Controllers/AdminController.cs

    r8e74e2f rdb484c9  
    33using System.Linq;
    44using System.Threading.Tasks;
     5using FarmatikoData.DTOs;
    56using FarmatikoData.Models;
    67using FarmatikoServices.FarmatikoServiceInterfaces;
    … …  
    4647        {
    4748            await _service.AddPharmacyHead(pharmacyHead);
    48             return Ok();
     49            return Ok("Pharmacy added.");
    4950        }
    5051
    … …  
    6566        [HttpPost]
    6667        [Route("api/pharmacyhead/{Id}")]
    67         public async Task<IActionResult> ApproveRequest([FromRoute]int Id, [FromBody]PharmacyHead pharmacyHead)
     68        public async Task<IActionResult> ApproveRequest([FromRoute]int Id, [FromBody]PharmacyHeadDto pharmacyHead)
    6869        {
    69             int id = Id;
    7070            await _phservice.UpdatePharmacyHead(pharmacyHead);
    7171            return Ok();

  • Farmatiko/Controllers/FarmatikoController.cs

    r8e74e2f rdb484c9  
    2424        {
    2525            //_JSONservice.DownloadPharmaciesExcel();
    26             _JSONservice.GetProcessedHealthcareWorkersFromJSON();
     26            //_JSONservice.GetProcessedHealthcareWorkersFromJSON();
    2727            //_JSONservice.GetProcessedHealthFacilitiesFromJSON();
    2828            //_JSONservice.GetProcessedMedicinesFromJSON();

  • Farmatiko/Controllers/LoginController.cs

    r8e74e2f rdb484c9  
    8282        public ActionResult Logout()
    8383        {
    84             // optionally "revoke" JWT token on the server side --> add the current token to a block-list
    85             // https://github.com/auth0/node-jsonwebtoken/issues/375
    86 
    8784            var userName = User.Identity.Name;
    8885            _jwtAuthManager.RemoveRefreshTokenByUserName(userName);

  • Farmatiko/Controllers/PharmacyHeadController.cs

    r8e74e2f rdb484c9  
    11using System.Collections.Generic;
    22using System.Threading.Tasks;
     3using FarmatikoData.DTOs;
    34using FarmatikoData.Models;
    45using FarmatikoServices.FarmatikoServiceInterfaces;
    … …  
    1920
    2021        //GET
    21         /*
    22         [HttpGet]
    23         [Route("api/pharmacyhead")]
    24         public async Task<IEnumerable<PharmacyHead>> GetPharmacyHeadInfo()
    25         {
    26             var PHeads = await _PHService.GetPharmacyHeadInfo();
    27             return PHeads;
    28         }*/
    29 
     22       
    3023        [HttpGet]
    3124        [Route("api/pharmacyhead/{Id}")]
    … …  
    3629        }
    3730        //POST
    38         /*
    39                 [HttpPost]
    40                 [Route("api/pharmacyhead/add")]
    41                 public async Task<IActionResult> AddPharmacyHead([FromBody] PharmacyHead pharmacyHead)
    42                 {
    43                     bool Success = await _PHService.Add(pharmacyHead);
    44                     return Ok(Success);
    45                 }*/
    46 
    47         /*[HttpPost]
    48         [Route("api/pharmacyhead/login")]
    49         public async Task<int> Login([FromBody]PharmacyHead pharmacyHead)
    50         {
    51             return await _PHService.Login(pharmacyHead);
    52         }*/
     31       
    5332        [HttpPut]
    5433        [Route("api/pharmacyhead/update")]
    55         public async Task UpdatePharmacyHead([FromBody] PharmacyHead pharmacyHead)
     34        public async Task<IActionResult> UpdatePharmacyHead([FromBody] PharmacyHeadDto pharmacyHead)
    5635        {
    5736            await _PHService.UpdatePharmacyHead(pharmacyHead);
     37            return Ok();
    5838        }
    5939        [HttpPost]

  • FarmatikoData/FarmatikoDataContext.cs

    r8e74e2f rdb484c9  
    99
    1010
    11         public virtual DbSet<HealthFacility> HealthFacilities { get; set; }
    12         public virtual DbSet<HealthcareWorker> HealthcareWorkers { get; set; }
    13         public virtual DbSet<Pharmacy> Pharmacies { get; set; }
    14         public virtual DbSet<PharmacyHead> PharmacyHeads { get; set; }
    15         public virtual DbSet<Pandemic> Pandemics { get; set; }
    16         public virtual DbSet<Medicine> Medicines { get; set; }
    17         public virtual DbSet<RequestPharmacyHead> PHRequests { get; set; }
    18         public virtual DbSet<User> Users { get; set; }
    19         public virtual DbSet<PharmacyHeadMedicine> PharmacyHeadMedicines { get; set; }
     11        public DbSet<HealthFacility> HealthFacilities { get; set; }
     12        public DbSet<HealthcareWorker> HealthcareWorkers { get; set; }
     13        public DbSet<Pharmacy> Pharmacies { get; set; }
     14        public DbSet<PharmacyHead> PharmacyHeads { get; set; }
     15        public DbSet<Pandemic> Pandemics { get; set; }
     16        public DbSet<Medicine> Medicines { get; set; }
     17        public DbSet<RequestPharmacyHead> PHRequests { get; set; }
     18        public DbSet<User> Users { get; set; }
     19        public DbSet<PharmacyHeadMedicine> PharmacyHeadMedicines { get; set; }
    2020
    2121        protected override void OnModelCreating(ModelBuilder modelBuilder)
    … …  
    3131            modelBuilder.Entity<Pharmacy>()
    3232                .ToTable("Pharmacies");
     33
     34            modelBuilder.Entity<PharmacyHeadMedicine>()
     35                .ToTable("PharmacyHeadMedicines");
     36
     37            modelBuilder.Entity<RequestPharmacyHead>()
     38                .ToTable("PHRequests");
    3339
    3440            modelBuilder.Entity<Medicine>()
    … …  
    5258                .HasIdentityOptions(startValue: 1);
    5359
    54             modelBuilder.Entity<User>()
     60            /*modelBuilder.Entity<User>()
    5561                .Property(x => x.Id)
    5662                .HasIdentityOptions(startValue: 1);
    … …  
    5864            modelBuilder.Entity<PharmacyHeadMedicine>()
    5965                .HasKey(phm => new { phm.PheadId, phm.MedicineId });
    60             modelBuilder.Entity<PharmacyHeadMedicine>()
    61                 .HasOne(ph => ph.Head)
    62                 .WithMany(m => m.PHMedicineList)
    63                 .HasForeignKey(k => k.PheadId);
    64 
    65             modelBuilder.Entity<PharmacyHeadMedicine>()
    66                 .HasOne(m => m.Medicine)
    67                 .WithMany(ml => ml.MedicineList)
    68                 .HasForeignKey(k => k.MedicineId);
    6966
    7067            modelBuilder.Entity<PharmacyHead>()
    71                 .HasMany(p => p.PharmaciesList)
    72                 .WithOne(h => h.PHead)
    73                 .HasForeignKey(k => k.PheadId);
     68                .HasMany<Pharmacy>(p => p.Pharmacy)
     69                .WithOne(p => p.PharmacyHead)
     70                .HasForeignKey();
    7471
    75 
    76 
     72            modelBuilder.Entity<Pharmacy>()
     73                .HasOne<PharmacyHead>(p => p.PharmacyHead)
     74                .WithMany(p => p.Pharmacy);
     75            */
     76           
    7777            base.OnModelCreating(modelBuilder);
    7878        }

  • FarmatikoData/FarmatikoRepo/AdminRepo.cs

    r8e74e2f rdb484c9  
    2727        public async Task<IEnumerable<PharmacyHead>> GetPharmacyHeads()
    2828        {
    29             var PHeads = await _context.PharmacyHeads.OrderBy(x => x.Name).ToListAsync();
     29            var PHeads = await _context.PharmacyHeads
     30                .Include(x => x.Medicines)
     31                .Include(x => x.Pharmacies)
     32                .OrderBy(x => x.Name)
     33                .ToListAsync();
    3034            return PHeads;
    3135        }
    3236        //POST
    33         public void RemoveClaimRequest(int Id)
     37        public async void RemoveClaimRequest(int Id)
    3438        {
    3539            var req = _context.PHRequests.Where(x => x.Id == Id).FirstOrDefault();
    3640            _context.PHRequests.Remove(req);
    37             _context.SaveChanges();
     41            await _context.SaveChangesAsync();
    3842        }
    3943    }

  • FarmatikoData/FarmatikoRepo/PHRepo.cs

    r8e74e2f rdb484c9  
    2424        public async Task<IEnumerable<PharmacyHead>> GetPharmacyHeadInfo()
    2525        {
    26             var PHeadInfo = await _context.PharmacyHeads.Take(10).Where(x => x.DeletedOn == null)
     26            var PHeadInfo = await _context.PharmacyHeads.Take(10)
     27                .Where(x => x.DeletedOn == null)
    2728                .Select(x => new PharmacyHead
    2829                {
    … …  
    3132                    Email = x.Email,
    3233                    Password = x.Password,
    33                     MedicineList = x.MedicineList,
    34                     PharmaciesList = x.PharmaciesList
     34                    Pharmacies = x.Pharmacies,
     35                    Medicines = x.Medicines
     36
    3537                }).ToListAsync();
    3638            return PHeadInfo;
    … …  
    4143            var Phead = await _context.PharmacyHeads.Where(x => x.Email == pharmacyHead.Email).FirstOrDefaultAsync();
    4244            var EditedPHead = await _context.PharmacyHeads.AsNoTracking<PharmacyHead>().Where(x => x.Email == pharmacyHead.Email).FirstOrDefaultAsync();
    43             EditedPHead.Email = pharmacyHead.Email;
    44             EditedPHead.Name = pharmacyHead.Name;
    45             EditedPHead.Password = pharmacyHead.Password;
    46             /*if (pharmacyHead.MedicineList.Count() == 0)
    47                 pharmacyHead.MedicineList = null;*/
    48             EditedPHead.MedicineList = pharmacyHead.MedicineList;
    49             EditedPHead.PharmaciesList = pharmacyHead.PharmaciesList;
    50             EditedPHead.PHMedicineList = pharmacyHead.PHMedicineList;
    51             //_context.Entry<PharmacyHead>(Phead).State = EntityState.Detached;
    52             //Phead = EditedPHead;
     45
     46            if (!EditedPHead.Email.Equals(pharmacyHead.Email))
     47                EditedPHead.Email = pharmacyHead.Email;
     48
     49            if (!EditedPHead.Name.Equals(pharmacyHead.Name))
     50                EditedPHead.Name = pharmacyHead.Name;
     51
     52            if (!EditedPHead.Password.Equals(pharmacyHead.Password))
     53                EditedPHead.Password = pharmacyHead.Password;
     54
     55            if (!EditedPHead.Pharmacies.Equals(pharmacyHead.Pharmacies))
     56                EditedPHead.Pharmacies = pharmacyHead.Pharmacies;
     57
     58            if (!EditedPHead.Medicines.Equals(pharmacyHead.Medicines))
     59                EditedPHead.Medicines = pharmacyHead.Medicines;
     60
    5361            await _context.SaveChangesAsync();
    5462        }
    … …  
    8189        public PharmacyHead GetPharmacyHeadByUserName(string userName)
    8290        {
     91
     92                       
    8393            var PHead = _context.PharmacyHeads
    8494                .Where(x => x.Email.Equals(userName))
    85                 .FirstOrDefault();
     95                .Select(x => new PharmacyHead
     96                {
     97                   Email = x.Email,
     98                   Name = x.Name,
     99                   Password = x.Password,
     100                   Medicines = x.Medicines,
     101                   Pharmacies = x.Pharmacies
     102                }).FirstOrDefault();
     103
     104           
    86105
    87106            return PHead;
    … …  
    90109        public List<PharmacyHeadMedicine> GetPharmacyHeadMedicines(string email)
    91110        {
    92             /*var meds = _context.Medicines.ToList();
    93             var medicines = Medicines;*/
    94111            var Phead = _context.PharmacyHeads.Where(x => x.Email.Equals(email)).FirstOrDefault();
    95             var Medicines = _context.PharmacyHeadMedicines.Where(x => x.PheadId == Phead.Id).ToList();
    96                 /*.Select(x => x.Head.MedicineList)
    97                 .SelectMany(mList => mList)
    98                 .ToList();*/
     112            var Medicines = _context.PharmacyHeadMedicines.Select(x => new PharmacyHeadMedicine
     113            {
     114                PheadId = x.PheadId,
     115                Head = x.Head,
     116                MedicineId = x.MedicineId,
     117                Medicine = x.Medicine
     118            }).ToList();
     119            if (Medicines == null || Medicines == default)
     120                Medicines = null;
     121            var meds = Medicines.Where(x => x.PheadId == Phead.Id).ToList();
    99122
    100 
    101             return Medicines;
     123            return meds;
    102124        }
    103125

  • FarmatikoData/FarmatikoRepo/Repository.cs

    r8e74e2f rdb484c9  
    8686            var SearchQuery = await _context.HealthFacilities
    8787            .Where(x => x.Name.Contains(query))
    88             .OrderBy(x => x.Name).Take(3).ToListAsync();
     88            .OrderBy(x => x.Name).ToListAsync();
    8989
    9090            return SearchQuery;
    … …  
    9595            var SearchQuery = await _context.Medicines
    9696            .Where(x => x.Name.Contains(query))
    97             .OrderBy(x => x.Name).Take(5).ToListAsync();
     97            .OrderBy(x => x.Name).ToListAsync();
    9898
    9999            return SearchQuery;
    … …  
    104104            var SearchQuery = await _context.Pharmacies.Take(5)
    105105            .Where(x => x.Name.Contains(query))
    106             .OrderBy(x => x.Name).Take(5).ToListAsync();
     106            .OrderBy(x => x.Name).ToListAsync();
    107107
    108108            return SearchQuery;
    … …  
    113113            var SearchQuery = await _context.HealthcareWorkers.Take(5)
    114114            .Where(x => x.Name.Contains(query))
    115             .OrderBy(x => x.Name).Take(5).ToListAsync();
     115            .OrderBy(x => x.Name).ToListAsync();
    116116
    117117            return SearchQuery;
    … …  
    170170            Facility.Phone = healthFacility.Phone;
    171171            Facility.Type = healthFacility.Type;
    172             _context.SaveChanges();
     172            await _context.SaveChangesAsync();
    173173        }
    174174
    175175        public async Task RemoveMedicine(Medicine medicine)
    176176        {
    177             await Task.Run(() => _context.Medicines.Remove(medicine));
    178             _context.SaveChanges();
     177            _context.Medicines.Remove(medicine);
     178            await _context.SaveChangesAsync();
    179179        }
    180180
    … …  
    190190            Pandemic.TotalGlobal = pandemic.TotalGlobal;
    191191            Pandemic.TotalMK = pandemic.TotalMK;
    192             _context.SaveChanges();
     192            await _context.SaveChangesAsync();
    193193        }
    194194
    195195        public async Task RemovePharmacy(Pharmacy pharmacy)
    196196        {
    197             await Task.Run(() => _context.Pharmacies.Remove(pharmacy));
    198             _context.SaveChanges();
     197            _context.Pharmacies.Remove(pharmacy);
     198            await _context.SaveChangesAsync();
    199199        }
    200200        //not impl
    … …  
    211211            Pharmacy.WorkAllTime = pharmacy.WorkAllTime;
    212212            Pharmacy.Address = pharmacy.Address;
    213             _context.SaveChanges();
    214         }
    215         //ke vidime
     213            await _context.SaveChangesAsync();
     214        }
     215        //not implemented, not needed
    216216        public Task UpdateMedicine(Medicine medicine)
    217217        {
    … …  
    223223            var PHead = await _context.PharmacyHeads.Where(x => x.Id == Id).FirstOrDefaultAsync();
    224224            PHead.DeletedOn = DateTime.UtcNow;
    225             _context.SaveChanges();
     225            await _context.SaveChangesAsync();
    226226        }
    227227
    … …  
    236236                UserRole = x.UserRole
    237237            });
     238           
    238239            return users;
    239240        }
    … …  
    257258                Price = x.Price,
    258259                Packaging = x.Packaging,
    259                 MedicineList = x.MedicineList
     260                Medicines = x.Medicines
    260261
    261262            }).ToList();
    … …  
    266267        {
    267268            var head = _context.PharmacyHeads.Where(x => x.Email.Equals(email)).FirstOrDefault();
    268             var phmeds = _context.PharmacyHeadMedicines.Where(x => x.PheadId == head.Id).ToList();
     269            var phmeds = _context.PharmacyHeadMedicines.Where(x => x.PheadId == head.Id).Include(x => x.Medicine).ToList();
    269270            return phmeds;
    270271        }

  • FarmatikoData/Migrations/20210124191844_InitialMigration.Designer.cs

    r8e74e2f rdb484c9  
    1111{
    1212    [DbContext(typeof(FarmatikoDataContext))]
    13     [Migration("20201115222819_InitialMigration")]
     13    [Migration("20210124191844_InitialMigration")]
    1414    partial class InitialMigration
    1515    {
    … …  
    124124                        .HasColumnType("text");
    125125
    126                     b.Property<int?>("PharmacyHeadId")
    127                         .HasColumnType("integer");
    128 
    129126                    b.Property<float>("Price")
    130127                        .HasColumnType("real");
    … …  
    140137                    b.HasKey("Id");
    141138
    142                     b.HasIndex("PharmacyHeadId");
    143 
    144139                    b.ToTable("Medicines");
    145140                });
    … …  
    214209                        .HasColumnType("text");
    215210
     211                    b.Property<int?>("PharmacyHeadId")
     212                        .HasColumnType("integer");
     213
    216214                    b.Property<int>("PheadId")
    217215                        .HasColumnType("integer");
    … …  
    222220                    b.HasKey("Id");
    223221
    224                     b.HasIndex("PheadId");
     222                    b.HasIndex("PharmacyHeadId");
    225223
    226224                    b.ToTable("Pharmacies");
    … …  
    253251                        .HasColumnType("text");
    254252
    255                     b.HasKey("Id");
     253                    b.Property<int?>("UserId")
     254                        .HasColumnType("integer");
     255
     256                    b.HasKey("Id");
     257
     258                    b.HasIndex("UserId");
    256259
    257260                    b.ToTable("PharmacyHeads");
    … …  
    260263            modelBuilder.Entity("FarmatikoData.Models.PharmacyHeadMedicine", b =>
    261264                {
     265                    b.Property<int>("Id")
     266                        .ValueGeneratedOnAdd()
     267                        .HasColumnType("integer")
     268                        .HasAnnotation("Npgsql:IdentitySequenceOptions", "'1', '1', '', '', 'False', '1'")
     269                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.SerialColumn);
     270
     271                    b.Property<DateTime>("CreatedOn")
     272                        .HasColumnType("timestamp without time zone");
     273
     274                    b.Property<DateTime?>("DeletedOn")
     275                        .HasColumnType("timestamp without time zone");
     276
     277                    b.Property<int?>("HeadId")
     278                        .HasColumnType("integer");
     279
     280                    b.Property<int>("MedicineId")
     281                        .HasColumnType("integer");
     282
    262283                    b.Property<int>("PheadId")
    263284                        .HasColumnType("integer");
    264285
    265                     b.Property<int>("MedicineId")
    266                         .HasColumnType("integer");
    267 
    268                     b.Property<DateTime>("CreatedOn")
    269                         .HasColumnType("timestamp without time zone");
    270 
    271                     b.Property<DateTime?>("DeletedOn")
    272                         .HasColumnType("timestamp without time zone");
    273 
    274                     b.Property<int>("Id")
    275                         .HasColumnType("integer")
    276                         .HasAnnotation("Npgsql:IdentitySequenceOptions", "'1', '1', '', '', 'False', '1'");
    277 
    278                     b.HasKey("PheadId", "MedicineId");
     286                    b.HasKey("Id");
     287
     288                    b.HasIndex("HeadId");
    279289
    280290                    b.HasIndex("MedicineId");
    … …  
    317327                        .ValueGeneratedOnAdd()
    318328                        .HasColumnType("integer")
    319                         .HasAnnotation("Npgsql:IdentitySequenceOptions", "'1', '1', '', '', 'False', '1'")
    320329                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.SerialColumn);
    321330
    … …  
    355364                });
    356365
    357             modelBuilder.Entity("FarmatikoData.Models.Medicine", b =>
    358                 {
    359                     b.HasOne("FarmatikoData.Models.PharmacyHead", null)
    360                         .WithMany("MedicineList")
     366            modelBuilder.Entity("FarmatikoData.Models.Pharmacy", b =>
     367                {
     368                    b.HasOne("FarmatikoData.Models.PharmacyHead", "PharmacyHead")
     369                        .WithMany("Pharmacies")
    361370                        .HasForeignKey("PharmacyHeadId");
    362371                });
    363372
    364             modelBuilder.Entity("FarmatikoData.Models.Pharmacy", b =>
    365                 {
    366                     b.HasOne("FarmatikoData.Models.PharmacyHead", "PHead")
    367                         .WithMany("PharmaciesList")
    368                         .HasForeignKey("PheadId")
    369                         .OnDelete(DeleteBehavior.Cascade)
    370                         .IsRequired();
     373            modelBuilder.Entity("FarmatikoData.Models.PharmacyHead", b =>
     374                {
     375                    b.HasOne("FarmatikoData.Models.User", "User")
     376                        .WithMany()
     377                        .HasForeignKey("UserId");
    371378                });
    372379
    373380            modelBuilder.Entity("FarmatikoData.Models.PharmacyHeadMedicine", b =>
    374381                {
     382                    b.HasOne("FarmatikoData.Models.PharmacyHead", "Head")
     383                        .WithMany("Medicines")
     384                        .HasForeignKey("HeadId");
     385
    375386                    b.HasOne("FarmatikoData.Models.Medicine", "Medicine")
    376                         .WithMany("MedicineList")
     387                        .WithMany("Medicines")
    377388                        .HasForeignKey("MedicineId")
    378                         .OnDelete(DeleteBehavior.Cascade)
    379                         .IsRequired();
    380 
    381                     b.HasOne("FarmatikoData.Models.PharmacyHead", "Head")
    382                         .WithMany("PHMedicineList")
    383                         .HasForeignKey("PheadId")
    384389                        .OnDelete(DeleteBehavior.Cascade)
    385390                        .IsRequired();

  • FarmatikoData/Migrations/20210124191844_InitialMigration.cs

    r8e74e2f rdb484c9  
    1515                    Id = table.Column<int>(nullable: false)
    1616                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.SerialColumn),
    17                     CreatedOn = table.Column<DateTime>(nullable: false, defaultValueSql:"now()"),
     17                    CreatedOn = table.Column<DateTime>(nullable: false, defaultValueSql: "now()"),
    1818                    DeletedOn = table.Column<DateTime>(nullable: true),
    1919                    Name = table.Column<string>(nullable: false),
    … …  
    2727                {
    2828                    table.PrimaryKey("PK_HealthFacilities", x => x.Id);
     29                });
     30
     31            migrationBuilder.CreateTable(
     32                name: "Medicines",
     33                columns: table => new
     34                {
     35                    Id = table.Column<int>(nullable: false)
     36                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.SerialColumn),
     37                    CreatedOn = table.Column<DateTime>(nullable: false, defaultValueSql: "now()"),
     38                    DeletedOn = table.Column<DateTime>(nullable: true),
     39                    Name = table.Column<string>(nullable: false),
     40                    Strength = table.Column<string>(nullable: false),
     41                    Form = table.Column<string>(nullable: true),
     42                    WayOfIssuing = table.Column<string>(nullable: false),
     43                    Manufacturer = table.Column<string>(nullable: false),
     44                    Price = table.Column<float>(nullable: false),
     45                    Packaging = table.Column<string>(nullable: true)
     46                },
     47                constraints: table =>
     48                {
     49                    table.PrimaryKey("PK_Medicines", x => x.Id);
    2950                });
    3051
    … …  
    5273
    5374            migrationBuilder.CreateTable(
    54                 name: "PharmacyHeads",
    55                 columns: table => new
    56                 {
    57                     Id = table.Column<int>(nullable: false)
    58                         .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.SerialColumn),
    59                     CreatedOn = table.Column<DateTime>(nullable: false, defaultValueSql: "now()"),
    60                     DeletedOn = table.Column<DateTime>(nullable: true),
    61                     Email = table.Column<string>(nullable: false),
    62                     Name = table.Column<string>(nullable: false),
    63                     Password = table.Column<string>(nullable: false)
    64                 },
    65                 constraints: table =>
    66                 {
    67                     table.PrimaryKey("PK_PharmacyHeads", x => x.Id);
    68                 });
    69 
    70             migrationBuilder.CreateTable(
    7175                name: "Users",
    7276                columns: table => new
    … …  
    111115
    112116            migrationBuilder.CreateTable(
    113                 name: "Medicines",
    114                 columns: table => new
    115                 {
    116                     Id = table.Column<int>(nullable: false)
    117                         .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.SerialColumn),
    118                     CreatedOn = table.Column<DateTime>(nullable: false, defaultValueSql: "now()"),
    119                     DeletedOn = table.Column<DateTime>(nullable: true),
    120                     Name = table.Column<string>(nullable: false),
    121                     Strength = table.Column<string>(nullable: false),
    122                     Form = table.Column<string>(nullable: true),
    123                     WayOfIssuing = table.Column<string>(nullable: false),
    124                     Manufacturer = table.Column<string>(nullable: false),
    125                     Price = table.Column<float>(nullable: false),
    126                     Packaging = table.Column<string>(nullable: true),
    127                     PharmacyHeadId = table.Column<int>(nullable: true)
    128                 },
    129                 constraints: table =>
    130                 {
    131                     table.PrimaryKey("PK_Medicines", x => x.Id);
    132                     table.ForeignKey(
    133                         name: "FK_Medicines_PharmacyHeads_PharmacyHeadId",
    134                         column: x => x.PharmacyHeadId,
    135                         principalTable: "PharmacyHeads",
     117                name: "PharmacyHeads",
     118                columns: table => new
     119                {
     120                    Id = table.Column<int>(nullable: false)
     121                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.SerialColumn),
     122                    CreatedOn = table.Column<DateTime>(nullable: false, defaultValueSql: "now()"),
     123                    DeletedOn = table.Column<DateTime>(nullable: true),
     124                    Email = table.Column<string>(nullable: false),
     125                    Name = table.Column<string>(nullable: false),
     126                    Password = table.Column<string>(nullable: false),
     127                    UserId = table.Column<int>(nullable: true)
     128                },
     129                constraints: table =>
     130                {
     131                    table.PrimaryKey("PK_PharmacyHeads", x => x.Id);
     132                    table.ForeignKey(
     133                        name: "FK_PharmacyHeads_Users_UserId",
     134                        column: x => x.UserId,
     135                        principalTable: "Users",
    136136                        principalColumn: "Id",
    137137                        onDelete: ReferentialAction.Restrict);
    … …  
    150150                    Address = table.Column<string>(nullable: false),
    151151                    WorkAllTime = table.Column<bool>(nullable: false),
    152                     PheadId = table.Column<int>(nullable: false)
     152                    PheadId = table.Column<int>(nullable: false),
     153                    PharmacyHeadId = table.Column<int>(nullable: true)
    153154                },
    154155                constraints: table =>
    … …  
    156157                    table.PrimaryKey("PK_Pharmacies", x => x.Id);
    157158                    table.ForeignKey(
    158                         name: "FK_Pharmacies_PharmacyHeads_PheadId",
    159                         column: x => x.PheadId,
     159                        name: "FK_Pharmacies_PharmacyHeads_PharmacyHeadId",
     160                        column: x => x.PharmacyHeadId,
    160161                        principalTable: "PharmacyHeads",
    161162                        principalColumn: "Id",
    162                         onDelete: ReferentialAction.Cascade);
     163                        onDelete: ReferentialAction.Restrict);
    163164                });
    164165
    … …  
    167168                columns: table => new
    168169                {
     170                    Id = table.Column<int>(nullable: false)
     171                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.SerialColumn),
     172                    CreatedOn = table.Column<DateTime>(nullable: false, defaultValueSql: "now()"),
     173                    DeletedOn = table.Column<DateTime>(nullable: true),
    169174                    PheadId = table.Column<int>(nullable: false),
    170                     MedicineId = table.Column<int>(nullable: false),
    171                     Id = table.Column<int>(nullable: false),
    172                     CreatedOn = table.Column<DateTime>(nullable: false, defaultValueSql: "now()"),
    173                     DeletedOn = table.Column<DateTime>(nullable: true)
    174                 },
    175                 constraints: table =>
    176                 {
    177                     table.PrimaryKey("PK_PharmacyHeadMedicines", x => new { x.PheadId, x.MedicineId });
     175                    HeadId = table.Column<int>(nullable: true),
     176                    MedicineId = table.Column<int>(nullable: false)
     177                },
     178                constraints: table =>
     179                {
     180                    table.PrimaryKey("PK_PharmacyHeadMedicines", x => x.Id);
     181                    table.ForeignKey(
     182                        name: "FK_PharmacyHeadMedicines_PharmacyHeads_HeadId",
     183                        column: x => x.HeadId,
     184                        principalTable: "PharmacyHeads",
     185                        principalColumn: "Id",
     186                        onDelete: ReferentialAction.Restrict);
    178187                    table.ForeignKey(
    179188                        name: "FK_PharmacyHeadMedicines_Medicines_MedicineId",
    … …  
    182191                        principalColumn: "Id",
    183192                        onDelete: ReferentialAction.Cascade);
    184                     table.ForeignKey(
    185                         name: "FK_PharmacyHeadMedicines_PharmacyHeads_PheadId",
    186                         column: x => x.PheadId,
    187                         principalTable: "PharmacyHeads",
    188                         principalColumn: "Id",
    189                         onDelete: ReferentialAction.Cascade);
    190193                });
    191194
    … …  
    224227
    225228            migrationBuilder.CreateIndex(
    226                 name: "IX_Medicines_PharmacyHeadId",
    227                 table: "Medicines",
     229                name: "IX_Pharmacies_PharmacyHeadId",
     230                table: "Pharmacies",
    228231                column: "PharmacyHeadId");
    229232
    230233            migrationBuilder.CreateIndex(
    231                 name: "IX_Pharmacies_PheadId",
    232                 table: "Pharmacies",
    233                 column: "PheadId");
     234                name: "IX_PharmacyHeadMedicines_HeadId",
     235                table: "PharmacyHeadMedicines",
     236                column: "HeadId");
    234237
    235238            migrationBuilder.CreateIndex(
    … …  
    237240                table: "PharmacyHeadMedicines",
    238241                column: "MedicineId");
     242
     243            migrationBuilder.CreateIndex(
     244                name: "IX_PharmacyHeads_UserId",
     245                table: "PharmacyHeads",
     246                column: "UserId");
    239247
    240248            migrationBuilder.CreateIndex(
    … …  
    264272
    265273            migrationBuilder.DropTable(
     274                name: "HealthFacilities");
     275
     276            migrationBuilder.DropTable(
     277                name: "Medicines");
     278
     279            migrationBuilder.DropTable(
     280                name: "Pharmacies");
     281
     282            migrationBuilder.DropTable(
     283                name: "PharmacyHeads");
     284
     285            migrationBuilder.DropTable(
    266286                name: "Users");
    267 
    268             migrationBuilder.DropTable(
    269                 name: "HealthFacilities");
    270 
    271             migrationBuilder.DropTable(
    272                 name: "Medicines");
    273 
    274             migrationBuilder.DropTable(
    275                 name: "Pharmacies");
    276 
    277             migrationBuilder.DropTable(
    278                 name: "PharmacyHeads");
    279287        }
    280288    }

  • FarmatikoData/Migrations/FarmatikoDataContextModelSnapshot.cs

    r8e74e2f rdb484c9  
    122122                        .HasColumnType("text");
    123123
    124                     b.Property<int?>("PharmacyHeadId")
    125                         .HasColumnType("integer");
    126 
    127124                    b.Property<float>("Price")
    128125                        .HasColumnType("real");
    … …  
    138135                    b.HasKey("Id");
    139136
    140                     b.HasIndex("PharmacyHeadId");
    141 
    142137                    b.ToTable("Medicines");
    143138                });
    … …  
    212207                        .HasColumnType("text");
    213208
     209                    b.Property<int?>("PharmacyHeadId")
     210                        .HasColumnType("integer");
     211
    214212                    b.Property<int>("PheadId")
    215213                        .HasColumnType("integer");
    … …  
    220218                    b.HasKey("Id");
    221219
    222                     b.HasIndex("PheadId");
     220                    b.HasIndex("PharmacyHeadId");
    223221
    224222                    b.ToTable("Pharmacies");
    … …  
    251249                        .HasColumnType("text");
    252250
    253                     b.HasKey("Id");
     251                    b.Property<int?>("UserId")
     252                        .HasColumnType("integer");
     253
     254                    b.HasKey("Id");
     255
     256                    b.HasIndex("UserId");
    254257
    255258                    b.ToTable("PharmacyHeads");
    … …  
    258261            modelBuilder.Entity("FarmatikoData.Models.PharmacyHeadMedicine", b =>
    259262                {
     263                    b.Property<int>("Id")
     264                        .ValueGeneratedOnAdd()
     265                        .HasColumnType("integer")
     266                        .HasAnnotation("Npgsql:IdentitySequenceOptions", "'1', '1', '', '', 'False', '1'")
     267                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.SerialColumn);
     268
     269                    b.Property<DateTime>("CreatedOn")
     270                        .HasColumnType("timestamp without time zone");
     271
     272                    b.Property<DateTime?>("DeletedOn")
     273                        .HasColumnType("timestamp without time zone");
     274
     275                    b.Property<int?>("HeadId")
     276                        .HasColumnType("integer");
     277
     278                    b.Property<int>("MedicineId")
     279                        .HasColumnType("integer");
     280
    260281                    b.Property<int>("PheadId")
    261282                        .HasColumnType("integer");
    262283
    263                     b.Property<int>("MedicineId")
    264                         .HasColumnType("integer");
    265 
    266                     b.Property<DateTime>("CreatedOn")
    267                         .HasColumnType("timestamp without time zone");
    268 
    269                     b.Property<DateTime?>("DeletedOn")
    270                         .HasColumnType("timestamp without time zone");
    271 
    272                     b.Property<int>("Id")
    273                         .HasColumnType("integer")
    274                         .HasAnnotation("Npgsql:IdentitySequenceOptions", "'1', '1', '', '', 'False', '1'");
    275 
    276                     b.HasKey("PheadId", "MedicineId");
     284                    b.HasKey("Id");
     285
     286                    b.HasIndex("HeadId");
    277287
    278288                    b.HasIndex("MedicineId");
    … …  
    315325                        .ValueGeneratedOnAdd()
    316326                        .HasColumnType("integer")
    317                         .HasAnnotation("Npgsql:IdentitySequenceOptions", "'1', '1', '', '', 'False', '1'")
    318327                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.SerialColumn);
    319328
    … …  
    353362                });
    354363
    355             modelBuilder.Entity("FarmatikoData.Models.Medicine", b =>
    356                 {
    357                     b.HasOne("FarmatikoData.Models.PharmacyHead", null)
    358                         .WithMany("MedicineList")
     364            modelBuilder.Entity("FarmatikoData.Models.Pharmacy", b =>
     365                {
     366                    b.HasOne("FarmatikoData.Models.PharmacyHead", "PharmacyHead")
     367                        .WithMany("Pharmacies")
    359368                        .HasForeignKey("PharmacyHeadId");
    360369                });
    361370
    362             modelBuilder.Entity("FarmatikoData.Models.Pharmacy", b =>
    363                 {
    364                     b.HasOne("FarmatikoData.Models.PharmacyHead", "PHead")
    365                         .WithMany("PharmaciesList")
    366                         .HasForeignKey("PheadId")
    367                         .OnDelete(DeleteBehavior.Cascade)
    368                         .IsRequired();
     371            modelBuilder.Entity("FarmatikoData.Models.PharmacyHead", b =>
     372                {
     373                    b.HasOne("FarmatikoData.Models.User", "User")
     374                        .WithMany()
     375                        .HasForeignKey("UserId");
    369376                });
    370377
    371378            modelBuilder.Entity("FarmatikoData.Models.PharmacyHeadMedicine", b =>
    372379                {
     380                    b.HasOne("FarmatikoData.Models.PharmacyHead", "Head")
     381                        .WithMany("Medicines")
     382                        .HasForeignKey("HeadId");
     383
    373384                    b.HasOne("FarmatikoData.Models.Medicine", "Medicine")
    374                         .WithMany("MedicineList")
     385                        .WithMany("Medicines")
    375386                        .HasForeignKey("MedicineId")
    376                         .OnDelete(DeleteBehavior.Cascade)
    377                         .IsRequired();
    378 
    379                     b.HasOne("FarmatikoData.Models.PharmacyHead", "Head")
    380                         .WithMany("PHMedicineList")
    381                         .HasForeignKey("PheadId")
    382387                        .OnDelete(DeleteBehavior.Cascade)
    383388                        .IsRequired();

  • FarmatikoData/Models/Medicine.cs

    r8e74e2f rdb484c9  
    2323        public string Packaging { get; set; }
    2424        //[JsonPropertyName("PHMedicineList")]
    25         public ICollection<PharmacyHeadMedicine> MedicineList { get; set; }
     25        public ICollection<PharmacyHeadMedicine> Medicines { get; set; }
    2626        public Medicine(string Name, string Strength, string Form, string WayOfIssuing, string Manufacturer, float Price, string Packaging)
    2727        {

  • FarmatikoData/Models/Pharmacy.cs

    r8e74e2f rdb484c9  
    2727        }
    2828        public int PheadId { get; set; }
    29         public PharmacyHead PHead { get; internal set; }
     29        public PharmacyHead PharmacyHead { get; set; }
    3030    }
    3131}

  • FarmatikoData/Models/PharmacyHead.cs

    r8e74e2f rdb484c9  
    2121        [JsonProperty("Passwd")]
    2222        public string Password { get; set; }
     23        [JsonProperty("PharmacyList")]
     24        public virtual List<Pharmacy> Pharmacies { get; set; }
     25        public virtual List<PharmacyHeadMedicine> Medicines { get; set; }
     26       
     27        public User User { get; set; }
    2328
    24         [JsonProperty("PharmacyMedicines")]
    25         public List<Medicine> MedicineList { get; set; }
    26         [JsonProperty("Pharmacy")]
    27         public ICollection<Pharmacy> PharmaciesList { get; set; }
    28         //[JsonProperty("PHMedicineList")]
    29         public ICollection<PharmacyHeadMedicine> PHMedicineList { get; set; }
    3029
    3130    }

  • FarmatikoServices/FarmatikoServiceInterfaces/IPHService.cs

    r8e74e2f rdb484c9  
    1 using FarmatikoData.Models;
     1using FarmatikoData.DTOs;
     2using FarmatikoData.Models;
    23using System;
    34using System.Collections.Generic;
    … …  
    1112    {
    1213        Task<IEnumerable<PharmacyHead>> GetPharmacyHeadInfo();
    13         Task UpdatePharmacyHead(PharmacyHead pharmacyHead);
     14        Task UpdatePharmacyHead(PharmacyHeadDto pharmacyHead);
    1415        Task<int> Login(PharmacyHead pharmacyHead);
    1516        Task<bool> ClaimPharmacy(RequestPharmacyHead pharmacy);
    1617        Task<PharmacyHead> GetPharmacyHeadByIdAsync(int id);
    17         Task<bool> Add(PharmacyHead pharmacyHead);
     18        Task<bool> Add(PharmacyHeadDto pharmacyHead);
    1819        Task<bool> Remove(int id);
    1920        Task<bool> RemoveClaimingRequest(int id);
    20         object GetPharmacyHead(string userName);
     21        PharmacyHeadDto GetPharmacyHead(string userName);
    2122    }
    2223}

  • FarmatikoServices/Services/PHService.cs

    r8e74e2f rdb484c9  
    1 using FarmatikoData.FarmatikoRepoInterfaces;
     1using FarmatikoData.DTOs;
     2using FarmatikoData.FarmatikoRepoInterfaces;
    23using FarmatikoData.Models;
    34using FarmatikoServices.FarmatikoServiceInterfaces;
    … …  
    5758
    5859
    59         public async Task UpdatePharmacyHead(PharmacyHead pharmacyHead)
     60        public async Task UpdatePharmacyHead(PharmacyHeadDto pharmacyHead)
    6061        {
    6162            if (pharmacyHead != null)
    … …  
    6364                var phead = _iPHRepo.GetPharmacyHead(pharmacyHead.Email);
    6465
    65                 /*if (pharmacyHead.PharmaciesList.Count() == 0)
    66                     pharmacyHead.PharmaciesList = null;*/
    67 
    68 
    69                 phead.PHMedicineList = _repository.GetPHMedicines(phead.Email);
    70 
    71                 if (phead.MedicineList != pharmacyHead.MedicineList)
    72                 {
    73                     phead.MedicineList = pharmacyHead.MedicineList;
    74                     List<PharmacyHeadMedicine> list = new List<PharmacyHeadMedicine>();
    75                     if (pharmacyHead.MedicineList.Count() == 0)
    76                     {
    77                         phead.MedicineList = null;
    78                         int PHMId = phead.PHMedicineList.Select(x => x.Id).Single();
    79                         int phId = phead.PHMedicineList.Select(x => x.PheadId).Single();
    80                         int medId = phead.PHMedicineList.Select(x => x.MedicineId).Single();
     66                phead.Medicines = _repository.GetPHMedicines(phead.Email).ToList();
     67               
     68                List<Medicine> medicines = _repository.GetMedicines().ToList();
     69               
     70                List<Medicine> PHMedicines = medicines.Where(x => x.Id == phead.Medicines.Select(x => x.MedicineId).Single()).ToList();
     71               
     72                List<PharmacyHeadMedicine> list = new List<PharmacyHeadMedicine>();
     73
     74               
     75
     76                if (!pharmacyHead.Medicines.Equals(PHMedicines))
     77                {
     78                    //phead.Medicines = pharmacyHead.Medicines;
     79                    if (pharmacyHead.Medicines.Count() == 0)
     80                    {
     81                        phead.Medicines = null;
     82                        int PHMId = phead.Medicines.Select(x => x.Id).Single();
     83                        int phId = phead.Medicines.Select(x => x.PheadId).Single();
     84                        int medId = phead.Medicines.Select(x => x.MedicineId).Single();
    8185                        _iPHRepo.DeletePHMedicine(PHMId, phId, medId);
    8286                        return;
    8387                    }
    84                     List<PharmacyHeadMedicine> PHMList = new List<PharmacyHeadMedicine>();
    85                     if (phead.PHMedicineList == pharmacyHead.PHMedicineList)
    86                     {
    87                         foreach (var med in phead.MedicineList)
     88                    foreach (var med in pharmacyHead.Medicines)
     89                    {
     90
     91                        PharmacyHeadMedicine PHMObj = phead.Medicines.Select(x => new PharmacyHeadMedicine
    8892                        {
    89                             //list = phead.PHMedicineList.ToList();
    90 
    91                             var PHMObj = phead.PHMedicineList.Select(x => new PharmacyHeadMedicine
    92                             {
    93                                 Id = x.Id,
    94                                 PheadId = x.PheadId,
    95                                 Head = x.Head,
    96                                 MedicineId = x.MedicineId,
    97                                 Medicine = x.Medicine
    98                             }).Where(x => x.MedicineId == med.Id).Single();
    99                             if (PHMObj == null || PHMObj == default)
    100                                 break;
    101                             if (PHMObj.MedicineId == med.Id)
    102                                 list.Add(PHMObj);
    103 
    104                         }
    105 
    106                         phead.PHMedicineList = list;
     93                            Id = x.Id,
     94                            PheadId = x.PheadId,
     95                            Head = x.Head,
     96                            MedicineId = x.MedicineId,
     97                            Medicine = x.Medicine
     98                        }).Where(x => !x.Medicine.Equals(med)).Single();
     99                        if (PHMObj == null || PHMObj == default)
     100                            break;
     101                        if (PHMObj.MedicineId == med.Id)
     102                            list.Add(PHMObj);
     103
    107104                    }
    108105
     106                    phead.Medicines = list;
     107
    109108                    await _iPHRepo.UpdatePharmacyHead(phead);
    110109                }
    111                 else if (!phead.Equals(pharmacyHead))
    112                 {
    113                     await _iPHRepo.UpdatePharmacyHead(pharmacyHead);
     110                PharmacyHead head = new PharmacyHead()
     111                {
     112                    Name = pharmacyHead.Name,
     113                    Email = pharmacyHead.Email,
     114                    Password = pharmacyHead.Password,
     115                    Pharmacies = pharmacyHead.Pharmacies,
     116                    Medicines = list
     117                };
     118                if (!phead.Equals(head))
     119                {
     120                    await _iPHRepo.UpdatePharmacyHead(head);
    114121                }
    115122                else throw new Exception("Cannot update pharmacy head since there was no changes.");
    … …  
    117124            else throw new Exception("PharmacyHead has a null value.");
    118125        }
    119         public async Task<bool> Add(PharmacyHead pharmacyHead)
     126        public async Task<bool> Add(PharmacyHeadDto pharmacyHead)
    120127        {
    121128            if (pharmacyHead != null)
    122129            {
    123                 await _iPHRepo.Add(pharmacyHead);
     130                PharmacyHead head = new PharmacyHead()
     131                {
     132                    Name = pharmacyHead.Name,
     133                    Email = pharmacyHead.Email,
     134                    Password = pharmacyHead.Password,
     135                    Pharmacies = null,
     136                    Medicines = null
     137                };
     138                await _iPHRepo.Add(head);
    124139                return true;
    125140            }
    … …  
    149164        }
    150165
    151         public object GetPharmacyHead(string userName)
     166        public PharmacyHeadDto GetPharmacyHead(string userName)
    152167        {
    153168            if (userName != null)
    … …  
    156171                List<PharmacyHeadMedicine> PHMedicines = _iPHRepo.GetPharmacyHeadMedicines(userName);
    157172                List<Medicine> Medicines = _repository.GetMedicines().ToList();
    158                 List<Medicine> PHMedicineList = new List<Medicine>();
    159 
    160 
    161                 //var meds = PHMedicines.Where(x => x.Id == Phead.Id).ToList();
    162                 var pharmacies = _iPHRepo.GetPharmacies();
    163                 var PheadPharms = pharmacies.Where(x => x.PheadId == Phead.Id).ToList();
     173                List<Medicine> MedicineList = new List<Medicine>();
     174
    164175                var user = _repository.GetRole(userName);
    165176
    … …  
    167178                if (user.UserRole.ToString().Equals("Admin"))
    168179                {
    169                     var Admin = new PharmacyHead()
     180                    List<Pharmacy> pharmacies = new List<Pharmacy>();
     181                    pharmacies = Phead.Pharmacies;
     182                    var Admin = new PharmacyHeadDto()
    170183                    {
    171184                        Id = user.Id,
    … …  
    173186                        Name = user.Name,
    174187                        Password = user.Password,
    175                         PharmaciesList = Phead.PharmaciesList
     188                        Pharmacies = pharmacies
    176189                    };
    177190
    178191                    return Admin;
    179192                }
    180 
    181                 if (PheadPharms.Count() > 0 || PheadPharms != null)
    182                     Phead.PharmaciesList = PheadPharms;
    183                 else Phead.PharmaciesList = pharmacies;
    184 
    185                 if (Phead.PHMedicineList.Count() > 0 || Phead.PHMedicineList != null)
     193                else
    186194                {
    187195                    foreach (var med in Medicines)
    188196                    {
    189 
    190                         var PHMObj = Phead.PHMedicineList.Where(x => x.MedicineId == med.Id).SingleOrDefault();
     197                        var PHMObj = Phead.Medicines.Where(x => x.MedicineId == med.Id).SingleOrDefault();
    191198                        if (PHMObj == null)
    192199                        {
    193200                            continue;
    194201                        }
    195                         var phm = Phead.MedicineList;
    196202                        if (PHMObj.MedicineId == med.Id)
    197203                        {
    … …  
    207213                                Packaging = med.Packaging
    208214                            };
    209                             PHMedicineList.Add(medicine);
     215                            MedicineList.Add(medicine);
    210216                        }
    211217                    }
    212                     Phead.MedicineList = PHMedicineList;
    213                 }
    214                 else
    215                 {
    216                     Phead.MedicineList = Medicines;
    217                 }
    218 
    219                 PharmacyHead pharHead = new PharmacyHead()
     218                }
     219
     220                PharmacyHeadDto pharmacyHead = new PharmacyHeadDto()
    220221                {
    221222                    Id = Phead.Id,
    222                     MedicineList = Phead.MedicineList,
    223                     PharmaciesList = Phead.PharmaciesList,
     223                    Medicines = MedicineList,
     224                    Pharmacies = Phead.Pharmacies,
    224225                    Email = Phead.Email,
    225226                    Name = Phead.Name,
    226227                    Password = Phead.Password
    227228                };
    228                 return pharHead;
     229                return pharmacyHead;
    229230            }
    230231            else throw new Exception("Username is null.");

  • FarmatikoServices/Services/ProcessJSONService.cs

    r8e74e2f rdb484c9  
    174174                    HealthFacility facility = _service.GetFacilityJSON(Convert.ToString(FacilityName));
    175175
    176                     if (facility != null)
     176                    if (facility != null && facility != default)
    177177                    {
    178178                        HealthFacility Facility = new HealthFacility(

  • FarmatikoServices/Services/Service.cs

    r8e74e2f rdb484c9  
    130130        public User MakeUser(PharmacyHead head)
    131131        {
    132             var users = _repository.GetUsers();
     132           
    133133           
    134134            User user = new User()

  • FarmatikoServices/Services/SystemService.cs

    r8e74e2f rdb484c9  
    77    public interface ISystemService
    88    {
    9 
     9        public void ParseHTML();
    1010    }
    1111    public class SystemService
Note: See TracChangeset for help on using the changeset viewer.