Blame view

src/MapsDb/DataService/RoadDs.cs 3.84 KB
b9b3b8dd   Administrator   add deteils and c...
1
2
3
4
5
6
  using System.Collections.Generic;
  using System.Linq;
  using System.Threading.Tasks;
  using MapsDb.Interfaces;
  using MapsDb.Models;
  using MapsModels.DsModels;
405bb8be   Yarik   Road
7
8
9
  using System.Reflection;
  using Microsoft.EntityFrameworkCore;
  
b9b3b8dd   Administrator   add deteils and c...
10
11
  namespace MapsDb.DataService
  {
27918c1f   Administrator   add service object
12
      public class RoadDs : IRoadDs
b9b3b8dd   Administrator   add deteils and c...
13
14
      {
          private PostgresDbContext _context;
27918c1f   Administrator   add service object
15
          public RoadDs(){
b9b3b8dd   Administrator   add deteils and c...
16
17
18
19
20
21
22
23
24
              _context = new PostgresDbContext();
          }
          public Task<IList<RoadSelectListDsM>> GetSelectListAsync(){
              return Task.Factory.StartNew(GetSelectList);
          }
          private IList<RoadSelectListDsM> GetSelectList()
          {
             return _context.Road.Select(x => new RoadSelectListDsM
              {
405bb8be   Yarik   Road
25
                  RoadId = x.Id, 
b9b3b8dd   Administrator   add deteils and c...
26
27
28
29
                  Name = x.Name
              }).ToList();
          }
  
405bb8be   Yarik   Road
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
          public Task<IList<RoadEditDsM>> GetIndexListAsync(PaginationDsM pagination){
              return Task.Factory.StartNew(()=> { return GetAllRoad(pagination); });
          }
          private IList<RoadEditDsM> GetAllRoad(PaginationDsM pagination)
          {
              var data =  _context.Road.Select(Road => new RoadEditDsM
              {
                  Id = Road.Id,
                  Name = Road.Name,
                  Value = Road.Value,
                  Length = Road.Length,
                  HistoricalBackground = Road.HistoricalBackground,
                  EconomicValue = Road.EconomicValue,
                  LawDoc = Road.LawDoc,
                  AcceptTransferDoc = Road.AcceptTransferDoc,
                  AcceptanceDoc = Road.AcceptanceDoc,
                  AuthorityAct = Road.AuthorityAct,
                  RoadTypeId = Road.RoadTypeId,
                  Index = Road.Index
              }).Skip(pagination.from).Take(pagination.perPage);
              switch (pagination.orderType())
              {
                  case "ASC":
                      return data.OrderBy(i => i.GetType().GetProperty(pagination.sort).GetValue(i, null)).ToList();
            
                  case "DESC":
                      return data.OrderByDescending(i => i.GetType().GetProperty(pagination.sort).GetValue(i, null)).ToList();
              
                  default:
                      return data.OrderByDescending(i => i.Id).ToList();
              }     
              
          }
  
          public Task<Road> CreateAsync(RoadEditDsM data){
                return Task.Factory.StartNew(()=> { return Create(data); });
          }
          private Road Create(RoadEditDsM data)
          {   
              
              Road Model = InsertModel(data);
              _context.Road.Add(Model);
              _context.SaveChanges();
              return Model;
          }
          public Task<Road> UpdateAsync(RoadEditDsM data, int id){
              return Task.Factory.StartNew(()=> { return Update(data, id); });
          }
          private Road Update(RoadEditDsM data, int id)
          {   
              Road Model = InsertModel(data);
              Model.Id = id;
              _context.Road.Update(Model);
              _context.SaveChanges();
              return Model;
          }
          public Road InsertModel(RoadEditDsM data){
              Road Model = new Road{
                  Name = data.Name,
                  Value = data.Value,
                  Length = data.Length,
                  HistoricalBackground = data.HistoricalBackground,
                  EconomicValue = data.EconomicValue,
                  LawDoc = data.LawDoc,
                  AcceptTransferDoc = data.AcceptTransferDoc,
                  AcceptanceDoc = data.AcceptanceDoc,
                  AuthorityAct = data.AuthorityAct,
                  RoadTypeId = data.RoadTypeId,
                  Index = data.Index
              };
              return Model;
          }
          public async Task<int> DeleteAsync(int Id)
          {
              var road = await _context.Road.SingleOrDefaultAsync(x => x.Id == Id);
              _context.Road.Remove(road);
              return await _context.SaveChangesAsync();
          }
  
b9b3b8dd   Administrator   add deteils and c...
109
110
      }
  }