Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
02/23/11 04:13:08 (13 years ago)
Author:
swagner
Message:

Worked on OKB (#1174)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/Administration/AdministrationClient.cs

    r5533 r5550  
    2424using System.Linq;
    2525using HeuristicLab.Clients.Common;
    26 using HeuristicLab.Collections;
    2726using HeuristicLab.Common;
    2827using HeuristicLab.Core;
    29 using HeuristicLab.PluginInfrastructure;
    3028
    3129namespace HeuristicLab.Clients.OKB.Administration {
    … …  
    6361    #endregion
    6462
    65     private AdministrationClient() {
    66       platforms = new ItemCollection<Platform>();
    67       platforms.ItemsRemoved += new CollectionItemsChangedEventHandler<Platform>(platforms_ItemsRemoved);
    68       algorithmClasses = new ItemCollection<AlgorithmClass>();
    69       algorithmClasses.ItemsRemoved += new CollectionItemsChangedEventHandler<AlgorithmClass>(algorithmClasses_ItemsRemoved);
    70       algorithms = new ItemCollection<Algorithm>();
    71       algorithms.ItemsRemoved += new CollectionItemsChangedEventHandler<Algorithm>(algorithms_ItemsRemoved);
    72       problemClasses = new ItemCollection<ProblemClass>();
    73       problemClasses.ItemsRemoved += new CollectionItemsChangedEventHandler<ProblemClass>(problemClasses_ItemsRemoved);
    74       problems = new ItemCollection<Problem>();
    75       problems.ItemsRemoved += new CollectionItemsChangedEventHandler<Problem>(problems_ItemsRemoved);
    76     }
     63    public AdministrationClient() { }
    7764
    7865    #region Refresh
    … …  
    8067      OnRefreshing();
    8168
    82       platforms.Clear();
    83       algorithmClasses.Clear();
    84       algorithms.Clear();
    85       problemClasses.Clear();
    86       problems.Clear();
    87 
     69      platforms = new OKBItemCollection<Platform>();
     70      algorithmClasses = new OKBItemCollection<AlgorithmClass>();
     71      algorithms = new OKBItemCollection<Algorithm>();
     72      problemClasses = new OKBItemCollection<ProblemClass>();
     73      problems = new OKBItemCollection<Problem>();
     74
     75      try {
     76        platforms.AddRange(CallAdministrationService<List<Platform>>(s => s.GetPlatforms()).OrderBy(x => x.Name));
     77        algorithmClasses.AddRange(CallAdministrationService<List<AlgorithmClass>>(s => s.GetAlgorithmClasses()).OrderBy(x => x.Name));
     78        algorithms.AddRange(CallAdministrationService<List<Algorithm>>(s => s.GetAlgorithms()).OrderBy(x => x.Name));
     79        problemClasses.AddRange(CallAdministrationService<List<ProblemClass>>(s => s.GetProblemClasses()).OrderBy(x => x.Name));
     80        problems.AddRange(CallAdministrationService<List<Problem>>(s => s.GetProblems()).OrderBy(x => x.Name));
     81      }
     82      finally {
     83        OnRefreshed();
     84      }
     85    }
     86    public void RefreshAsync(Action<Exception> exceptionCallback) {
    8887      var call = new Func<Exception>(delegate() {
    8988        try {
    90           platforms.AddRange(CallAdministrationService<List<Platform>>(s => s.GetPlatforms()).OrderBy(x => x.Name));
    91           algorithmClasses.AddRange(CallAdministrationService<List<AlgorithmClass>>(s => s.GetAlgorithmClasses()).OrderBy(x => x.Name));
    92           algorithms.AddRange(CallAdministrationService<List<Algorithm>>(s => s.GetAlgorithms()).OrderBy(x => x.Name));
    93           problemClasses.AddRange(CallAdministrationService<List<ProblemClass>>(s => s.GetProblemClasses()).OrderBy(x => x.Name));
    94           problems.AddRange(CallAdministrationService<List<Problem>>(s => s.GetProblems()).OrderBy(x => x.Name));
    95           return null;
     89          Refresh();
    9690        }
    9791        catch (Exception ex) {
    9892          return ex;
    9993        }
     94        return null;
    10095      });
    10196      call.BeginInvoke(delegate(IAsyncResult result) {
    10297        Exception ex = call.EndInvoke(result);
    103         if (ex != null) ErrorHandling.ShowErrorDialog("Refresh failed.", ex);
    104         OnRefreshed();
     98        if (ex != null) exceptionCallback(ex);
    10599      }, null);
    106100    }
    … …  
    108102
    109103    #region Store
    110     public bool Store(IOKBItem item) {
    111       try {
    112         if (item.Id == 0) {
    113           if (item is Platform)
    114             item.Id = CallAdministrationService<long>(s => s.AddPlatform((Platform)item));
    115           else if (item is AlgorithmClass)
    116             item.Id = CallAdministrationService<long>(s => s.AddAlgorithmClass((AlgorithmClass)item));
    117           else if (item is Algorithm)
    118             item.Id = CallAdministrationService<long>(s => s.AddAlgorithm((Algorithm)item));
    119           else if (item is ProblemClass)
    120             item.Id = CallAdministrationService<long>(s => s.AddProblemClass((ProblemClass)item));
    121           else if (item is Problem)
    122             item.Id = CallAdministrationService<long>(s => s.AddProblem((Problem)item));
    123         } else {
    124           if (item is Platform)
    125             CallAdministrationService(s => s.UpdatePlatform((Platform)item));
    126           else if (item is AlgorithmClass)
    127             CallAdministrationService(s => s.UpdateAlgorithmClass((AlgorithmClass)item));
    128           else if (item is Algorithm)
    129             CallAdministrationService(s => s.UpdateAlgorithm((Algorithm)item));
    130           else if (item is ProblemClass)
    131             CallAdministrationService(s => s.UpdateProblemClass((ProblemClass)item));
    132           else if (item is Problem)
    133             CallAdministrationService(s => s.UpdateProblem((Problem)item));
    134         }
    135         return true;
    136       }
    137       catch (Exception ex) {
    138         ErrorHandling.ShowErrorDialog("Store failed.", ex);
    139         return false;
    140       }
     104    public static void Store(IOKBItem item) {
     105      if (item.Id == 0) {
     106        if (item is Platform)
     107          item.Id = CallAdministrationService<long>(s => s.AddPlatform((Platform)item));
     108        else if (item is AlgorithmClass)
     109          item.Id = CallAdministrationService<long>(s => s.AddAlgorithmClass((AlgorithmClass)item));
     110        else if (item is Algorithm)
     111          item.Id = CallAdministrationService<long>(s => s.AddAlgorithm((Algorithm)item));
     112        else if (item is ProblemClass)
     113          item.Id = CallAdministrationService<long>(s => s.AddProblemClass((ProblemClass)item));
     114        else if (item is Problem)
     115          item.Id = CallAdministrationService<long>(s => s.AddProblem((Problem)item));
     116      } else {
     117        if (item is Platform)
     118          CallAdministrationService(s => s.UpdatePlatform((Platform)item));
     119        else if (item is AlgorithmClass)
     120          CallAdministrationService(s => s.UpdateAlgorithmClass((AlgorithmClass)item));
     121        else if (item is Algorithm)
     122          CallAdministrationService(s => s.UpdateAlgorithm((Algorithm)item));
     123        else if (item is ProblemClass)
     124          CallAdministrationService(s => s.UpdateProblemClass((ProblemClass)item));
     125        else if (item is Problem)
     126          CallAdministrationService(s => s.UpdateProblem((Problem)item));
     127      }
     128    }
     129    #endregion
     130
     131    #region Delete
     132    public static void Delete(IOKBItem item) {
     133      if (item is Platform)
     134        CallAdministrationService(s => s.DeletePlatform(item.Id));
     135      else if (item is AlgorithmClass)
     136        CallAdministrationService(s => s.DeleteAlgorithmClass(item.Id));
     137      else if (item is Algorithm)
     138        CallAdministrationService(s => s.DeleteAlgorithm(item.Id));
     139      else if (item is ProblemClass)
     140        CallAdministrationService(s => s.DeleteProblemClass(item.Id));
     141      else if (item is Problem)
     142        CallAdministrationService(s => s.DeleteProblem(item.Id));
     143      item.Id = 0;
    141144    }
    142145    #endregion
    143146
    144147    #region Algorithm Methods
    145     public List<Guid> GetAlgorithmUsers(long algorithmId) {
    146       try {
    147         return CallAdministrationService<List<Guid>>(s => s.GetAlgorithmUsers(algorithmId));
    148       }
    149       catch (Exception ex) {
    150         ErrorHandling.ShowErrorDialog("Refresh authorized algorithm users failed.", ex);
    151         return null;
    152       }
    153     }
    154     public bool UpdateAlgorithmUsers(long algorithmId, List<Guid> users) {
    155       try {
    156         CallAdministrationService(s => s.UpdateAlgorithmUsers(algorithmId, users));
    157         return true;
    158       }
    159       catch (Exception ex) {
    160         ErrorHandling.ShowErrorDialog("Update authorized algorithm users failed.", ex);
    161         return false;
    162       }
    163     }
    164     public byte[] GetAlgorithmData(long algorithmId) {
    165       try {
    166         return CallAdministrationService<byte[]>(s => s.GetAlgorithmData(algorithmId));
    167       }
    168       catch (Exception ex) {
    169         ErrorHandling.ShowErrorDialog("Refresh algorithm data failed.", ex);
    170         return null;
    171       }
    172     }
    173     public bool UpdateAlgorithmData(long algorithmId, byte[] algorithmData) {
    174       try {
    175         CallAdministrationService(s => s.UpdateAlgorithmData(algorithmId, algorithmData));
    176         return true;
    177       }
    178       catch (Exception ex) {
    179         ErrorHandling.ShowErrorDialog("Update algorithm data failed.", ex);
    180         return false;
    181       }
     148    public static List<Guid> GetAlgorithmUsers(long algorithmId) {
     149      return CallAdministrationService<List<Guid>>(s => s.GetAlgorithmUsers(algorithmId));
     150    }
     151    public static void UpdateAlgorithmUsers(long algorithmId, List<Guid> users) {
     152      CallAdministrationService(s => s.UpdateAlgorithmUsers(algorithmId, users));
     153    }
     154    public static byte[] GetAlgorithmData(long algorithmId) {
     155      return CallAdministrationService<byte[]>(s => s.GetAlgorithmData(algorithmId));
     156    }
     157    public static void UpdateAlgorithmData(long algorithmId, byte[] algorithmData) {
     158      CallAdministrationService(s => s.UpdateAlgorithmData(algorithmId, algorithmData));
    182159    }
    183160    #endregion
    184161
    185162    #region Problem Methods
    186     public List<Guid> GetProblemUsers(long problemId) {
    187       try {
    188         return CallAdministrationService<List<Guid>>(s => s.GetProblemUsers(problemId));
    189       }
    190       catch (Exception ex) {
    191         ErrorHandling.ShowErrorDialog("Refresh authorized problem users failed.", ex);
    192         return null;
    193       }
    194     }
    195     public bool UpdateProblemUsers(long problemId, List<Guid> users) {
    196       try {
    197         CallAdministrationService(s => s.UpdateProblemUsers(problemId, users));
    198         return true;
    199       }
    200       catch (Exception ex) {
    201         ErrorHandling.ShowErrorDialog("Update authorized problem users failed.", ex);
    202         return false;
    203       }
    204     }
    205     public byte[] GetProblemData(long problemId) {
    206       try {
    207         return CallAdministrationService<byte[]>(s => s.GetProblemData(problemId));
    208       }
    209       catch (Exception ex) {
    210         ErrorHandling.ShowErrorDialog("Refresh problem data failed.", ex);
    211         return null;
    212       }
    213     }
    214     public bool UpdateProblemData(long problemId, byte[] problemData) {
    215       try {
    216         CallAdministrationService(s => s.UpdateProblemData(problemId, problemData));
    217         return true;
    218       }
    219       catch (Exception ex) {
    220         ErrorHandling.ShowErrorDialog("Update problem data failed.", ex);
    221         return false;
    222       }
     163    public static List<Guid> GetProblemUsers(long problemId) {
     164      return CallAdministrationService<List<Guid>>(s => s.GetProblemUsers(problemId));
     165    }
     166    public static void UpdateProblemUsers(long problemId, List<Guid> users) {
     167      CallAdministrationService(s => s.UpdateProblemUsers(problemId, users));
     168    }
     169    public static byte[] GetProblemData(long problemId) {
     170      return CallAdministrationService<byte[]>(s => s.GetProblemData(problemId));
     171    }
     172    public static void UpdateProblemData(long problemId, byte[] problemData) {
     173      CallAdministrationService(s => s.UpdateProblemData(problemId, problemData));
    223174    }
    224175    #endregion
    … …  
    232183    public event EventHandler Refreshed;
    233184    private void OnRefreshed() {
    234       EventHandler handler = Refreshed;
     185      var handler = Refreshed;
    235186      if (handler != null) handler(this, EventArgs.Empty);
    236187    }
    237 
    238     private void platforms_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<Platform> e) {
    239       try {
    240         foreach (Platform p in e.Items)
    241           CallAdministrationService(s => s.DeletePlatform(p.Id));
    242       }
    243       catch (Exception ex) {
    244         ErrorHandling.ShowErrorDialog("Delete failed.", ex);
    245       }
    246     }
    247     private void algorithmClasses_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<AlgorithmClass> e) {
    248       try {
    249         foreach (AlgorithmClass a in e.Items)
    250           CallAdministrationService(s => s.DeleteAlgorithmClass(a.Id));
    251       }
    252       catch (Exception ex) {
    253         ErrorHandling.ShowErrorDialog("Delete failed.", ex);
    254       }
    255     }
    256     private void algorithms_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<Algorithm> e) {
    257       try {
    258         foreach (Algorithm a in e.Items)
    259           CallAdministrationService(s => s.DeleteAlgorithm(a.Id));
    260       }
    261       catch (Exception ex) {
    262         ErrorHandling.ShowErrorDialog("Delete failed.", ex);
    263       }
    264     }
    265     private void problemClasses_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<ProblemClass> e) {
    266       try {
    267         foreach (ProblemClass p in e.Items)
    268           CallAdministrationService(s => s.DeleteProblemClass(p.Id));
    269       }
    270       catch (Exception ex) {
    271         ErrorHandling.ShowErrorDialog("Delete failed.", ex);
    272       }
    273     }
    274     private void problems_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<Problem> e) {
    275       try {
    276         foreach (Problem p in e.Items)
    277           CallAdministrationService(s => s.DeleteProblem(p.Id));
    278       }
    279       catch (Exception ex) {
    280         ErrorHandling.ShowErrorDialog("Delete failed.", ex);
    281       }
    282     }
    283188    #endregion
    284189
    285190    #region Helpers
    286     private void CallAdministrationService(Action<IAdministrationService> call) {
     191    private static void CallAdministrationService(Action<IAdministrationService> call) {
    287192      AdministrationServiceClient client = ClientFactory.CreateClient<AdministrationServiceClient, IAdministrationService>();
    288193      try {
    … …  
    298203      }
    299204    }
    300     private T CallAdministrationService<T>(Func<IAdministrationService, T> call) {
     205    private static T CallAdministrationService<T>(Func<IAdministrationService, T> call) {
    301206      AdministrationServiceClient client = ClientFactory.CreateClient<AdministrationServiceClient, IAdministrationService>();
    302207      try {
Note: See TracChangeset for help on using the changeset viewer.