Exemple #1
0
        private async Task GetCemeteryAsync(SupervisorModel model)
        {
            if (CrossConnectivity.Current.IsConnected)
            {
                var cem = await _apiCemetery.GetCemeteryAsync(model.CemeteryId);

                if (cem.status == "Success")
                {
                    //will be used for cemetry location
                    var objDevice = new CemeteryGeolocationModel
                    {
                        CemeteryName = cem.objDevice.CemeteryLocation.CemeteryName,
                        Latitude     = cem.objDevice.CemeteryLocation.Latitude,
                        Longitude    = cem.objDevice.CemeteryLocation.Longitude,
                    };
                    Password = string.Empty;
                    Username = string.Empty;
                    await Application.Current.MainPage.Navigation.PushAsync(new Burials(model, _apiBurial));
                }
            }
            else
            {
                Device.BeginInvokeOnMainThread(() =>
                {
                    Application.Current.MainPage.DisplayAlert("Error Network Connection",
                                                              "You need to be connected to the internet and restart the application if possible",
                                                              "OK");
                    IsBusy = false;
                });
            }
        }
        public async Task <IHttpActionResult> Put([FromBody] SupervisorModel model)
        {
            IdentityUser user = await UserManager.FindByIdAsync(User.Identity.GetUserId());

            // Se obtiene el supervisor y se actualiza la fecha de modificación y el estatus
            var supervisor = supervisorService.GetSingle(c => c.SV_ID_SUPERVISOR == model.SV_ID_SUPERVISOR);

            if (supervisor != null)
            {
                supervisor.SV_FECHA_MOD       = DateTime.Now.Date;
                supervisor.SV_ESTATUS         = Convert.ToInt16(RegistryStateModel.RegistryState.Pendiente);
                supervisor.SV_FECHA_MOD       = DateTime.Now.Date;
                supervisor.SV_ID_AREA         = model.SV_ID_AREA;
                supervisor.CE_ID_EMPRESA      = model.CE_ID_EMPRESA;
                supervisor.SV_ID_SUPERVISOR   = model.SV_ID_SUPERVISOR;
                supervisor.SV_LIMITE_MINIMO   = model.SV_LIMITE_MINIMO;
                supervisor.SV_LIMITE_SUPERIOR = model.SV_LIMITE_SUPERIOR;

                //supervisorService.Update(supervisor);
                // Se obtiene el supervisor temporal para luego actualizarlo con el supervisor
                var supervisorTemp = supervisorTempService.GetSingle(c => c.SV_ID_SUPERVISOR == model.SV_ID_SUPERVISOR);
                supervisorTemp            = MappingTempFromSupervisor(supervisorTemp, supervisor);
                supervisorTemp.SV_ESTATUS = Convert.ToInt16(RegistryStateModel.RegistryState.PorAprobar);
                supervisorTempService.Update(supervisorTemp);
                return(Ok());
            }
            else
            {
                return(NotFound());
            }
        }
        public void ProcessDiscoveryWithNoResultsAndNoExistingApplications()
        {
            var found = new List <DiscoveryEventModel>();
            var fix   = new Fixture();

            var device      = fix.Create <string>();
            var module      = fix.Create <string>();
            var super       = SupervisorModelEx.CreateSupervisorId(device, module);
            var deviceModel = new DeviceModel {
                Id       = device,
                ModuleId = module
            };
            var twinModel = new SupervisorModel {
                Id = super
            }.ToSupervisorRegistration().ToDeviceTwin();

            var registry = IoTHubServices.Create((twinModel, deviceModel).YieldReturn());

            using (var mock = AutoMock.GetLoose()) {
                // Setup
                mock.Provide <IIoTHubTwinServices>(registry);
                mock.Provide <ISupervisorRegistry, SupervisorRegistry>();
                mock.Provide <IApplicationBulkProcessor, ApplicationRegistry>();
                mock.Provide <IEndpointBulkProcessor, EndpointRegistry>();
                var service = mock.Create <DiscoveryProcessor>();

                // Run
                service.ProcessDiscoveryResultsAsync(super, new DiscoveryResultModel(), found).Wait();

                // Assert
                Assert.Empty(registry.Devices);
            }
        }
        public async Task <IHttpActionResult> PutAprobarParametro([FromBody] AprobacionModel model)
        {
            IdentityUser user = await UserManager.FindByIdAsync(User.Identity.GetUserId());

            var tempModel = supervisorTempService.GetSingle(c => c.SV_ID_SUPERVISOR == model.id);

            int estadoAprobado = Convert.ToInt32(RegistryStateModel.RegistryState.Aprobado);
            var listSupervisor = supervisorService.GetAll(c => c.CE_ID_EMPRESA == tempModel.CE_ID_EMPRESA &&
                                                          c.SV_ID_AREA == tempModel.SV_ID_AREA &&
                                                          c.SV_ESTATUS == estadoAprobado &&
                                                          c.SV_COD_SUPERVISOR == tempModel.SV_COD_SUPERVISOR, null, includes: c => c.SAX_EMPRESA);

            if (listSupervisor != null & listSupervisor.Count > 0)
            {
                return(BadRequest("Supervisor duplicado, por favor rechazar."));
            }

            if (tempModel != null)
            {
                tempModel.SV_FECHA_APROBACION  = DateTime.Now.Date;
                tempModel.SV_ESTATUS           = Convert.ToInt16(RegistryStateModel.RegistryState.Aprobado);
                tempModel.SV_USUARIO_APROBADOR = user.Id;
                supervisorTempService.Update(tempModel);
                SupervisorModel supervisor = new SupervisorModel();
                supervisor = MappingSupervisorFromTemp(supervisor, tempModel);

                supervisorService.Update(supervisor);
                return(Ok("El supervisor ha sido aprobado."));
            }
            return(BadRequest("No se encontraron datos para actualizar."));
        }
        public BurialsViewModel(SupervisorModel model, IBurialService apiBurial)
        {
            if (CrossConnectivity.Current.IsConnected)
            {
                _apiBurial  = apiBurial;
                _supervisor = model;

                SupervisorId      = model.SupervisorId;
                _burialList       = new List <BurialModel>();
                _refreshCommand   = new Command(async() => await RefreshList(model));
                _sqLiteConnection = DependencyService.Get <ISQLite>().GetConnection();
                _sqLiteConnection.CreateTable <Burial>();
                _onTapGestureRecognizerTapped = new Command(OnTapped);
                OutputAgeCommand = new Command <BurialModel>(OutputAge);

                Reload();
            }
            else
            {
                Device.BeginInvokeOnMainThread(() =>
                {
                    Application.Current.MainPage.DisplayAlert("Error Network Connection",
                                                              "You need to be connected to the internet and restart the application",
                                                              "OK");
                    IsBusy = false;
                });
            }
        }
 public Burials(SupervisorModel model, IBurialService apiBurial)
 {
     InitializeComponent();
     this._model      = model;
     _apiBurial       = apiBurial;
     lblFullname.Text = model.Fullname;
     BindingContext   = _burialViewModel = new BurialsViewModel(model, apiBurial);
 }
        public async Task <bool> DeleteSupervisorAsync(SupervisorModel model)
        {
            var supervisor = _mapper.Map <Supervisor>(model);

            _parkRepository.Delete(supervisor);

            return(await _parkRepository.SaveChangesAsync());
        }
Exemple #8
0
        private void tbSupervisor_Click(object sender, EventArgs e)
        {
            SupervisorModel model    = UnityContainer.Resolve <SupervisorModel>();
            BaseView        baseView = model.CreateForm();

            baseView.MdiParent   = this;
            baseView.WindowState = FormWindowState.Maximized;
            baseView.Show();
        }
Exemple #9
0
        private async Task LoginAsync(SigninModel model)
        {
            await Task.Run(async() =>
            {
                try
                {
                    StartEnabled = false;
                    ButtonText   = "Signing-in...";
                    IsBusy       = true;


                    var results = await _apiServices.LoginAsync(model.Username, model.Password);
                    if (results.status == "Success" && results.objSupervisor != null)
                    {
                        var objSupervisor = new SupervisorModel()
                        {
                            CemeteryId         = results.objSupervisor.CemeteryId,
                            Name               = results.objSupervisor.Name,
                            Surname            = results.objSupervisor.Surname,
                            SupervisorId       = results.objSupervisor.SupervisorId,
                            UserName           = results.objSupervisor.UserName,
                            SupervisorPassword = results.objSupervisor.SupervisorPassword
                        };
                        _objSupervisor = objSupervisor;
                    }
                    else
                    {
                        Device.BeginInvokeOnMainThread(() =>
                        {
                            Application.Current.MainPage.DisplayAlert("Error login",
                                                                      "Username/Password invalid",
                                                                      "OK");
                            IsBusy       = false;
                            StartEnabled = true;
                            ButtonText   = "Sign-in";
                        });
                        _objSupervisor = null;
                    }
                }
                catch (Exception ex)
                {
                    Device.BeginInvokeOnMainThread(() =>
                    {
                        Application.Current.MainPage.DisplayAlert("Error Message",
                                                                  ex.Message,
                                                                  "OK");
                    });
                }
                finally
                {
                    IsBusy       = false;
                    StartEnabled = true;
                    ButtonText   = "Sign-in";
                }
            });
        }
Exemple #10
0
 /// <summary>
 /// Create supervisor event
 /// </summary>
 /// <param name="type"></param>
 /// <param name="context"></param>
 /// <param name="supervisorId"></param>
 /// <param name="supervisor"></param>
 /// <returns></returns>
 private static SupervisorEventModel Wrap(SupervisorEventType type,
                                          RegistryOperationContextModel context, string supervisorId,
                                          SupervisorModel supervisor)
 {
     return(new SupervisorEventModel {
         EventType = type,
         Context = context,
         Id = supervisorId,
         Supervisor = supervisor
     });
 }
 /// <summary>
 /// Create from service model
 /// </summary>
 /// <param name="model"></param>
 public SupervisorApiModel(SupervisorModel model)
 {
     Id              = model.Id;
     SiteId          = model.SiteId;
     Discovery       = model.Discovery;
     LogLevel        = model.LogLevel;
     DiscoveryConfig = model.DiscoveryConfig == null ? null :
                       new DiscoveryConfigApiModel(model.DiscoveryConfig);
     Certificate = model.Certificate;
     OutOfSync   = model.OutOfSync;
     Connected   = model.Connected;
 }
        private async Task <List <BurialModel> > PopulateList(SupervisorModel model)
        {
            Device.BeginInvokeOnMainThread(() => IsBusy = true);
            var items = await _apiBurial.GetBurialAsync(model.CemeteryId);

            if (items.objBurial.Count > 0)
            {
                await AddDataLocaly(items.objBurial.ToList());
            }
            Device.BeginInvokeOnMainThread(() => IsBusy = false);
            return(items.objBurial.ToList());
        }
        public async Task <SupervisorModel> AddNewSupervisorAsync(SupervisorModel model)
        {
            var supervisor = _mapper.Map <Supervisor>(model);

            _parkRepository.Add(supervisor);

            if (await _parkRepository.SaveChangesAsync())
            {
                return(_mapper.Map <SupervisorModel>(supervisor));
            }

            return(null);
        }
Exemple #14
0
 public DataTable selectbyUserid(SupervisorModel objSupervisorModel)
 {
     try
     {
         return(Execution.ExecuteParamerizedSelectCommand("sp_employee", new SqlParameter[]
         {
             new SqlParameter("@Command", "SELECTBYUSERIDFORSP"),
             new SqlParameter("@userId", objSupervisorModel.userid),
         }));
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
        public CoreProjectModel ScaffoldModel(OpenApiOptions options)
        {
            SupervisorModel          supervisorModel          = Supervisor.ScaffoldModel(options);
            SupervisorInterfaceModel supervisorInterfaceModel = SupervisorInterface.ScaffoldModel(options);

            return(new CoreProjectModel
            {
                ProjectFile = CreateProjectFile(options),
                Supervisor = supervisorModel.File,
                SupervisorInterface = supervisorInterfaceModel.File,
                Converters = Converter.ScaffoldModel(options).Files,
                Entities = Entities.ScaffoldModel(options).Files,
                ViewModels = ViewModels.ScaffoldModel(options).Files,
                RepositoryInterfaces = Repositories.ScaffoldModel(options).Files
            });
        }
 /// <summary>
 /// Create api model
 /// </summary>
 /// <param name="model"></param>
 /// <returns></returns>
 public static SupervisorApiModel ToApiModel(
     this SupervisorModel model)
 {
     if (model == null)
     {
         return(null);
     }
     return(new SupervisorApiModel {
         Id = model.Id,
         SiteId = model.SiteId,
         LogLevel = (IIoT.OpcUa.Api.Registry.Models.TraceLogLevel?)model.LogLevel,
         Certificate = model.Certificate,
         OutOfSync = model.OutOfSync,
         Connected = model.Connected
     });
 }
 public IHttpActionResult Post(SupervisorModel supervisor)
 {
     using (var context = new Entities())
     {
         context.Supporter
         .Add(new Supporter()
         {
             Id           = supervisor.Id,
             Name         = supervisor.Name,
             password     = supervisor.password,
             FirstSurname = supervisor.FirstSurname,
             Email        = supervisor.Email
         });
         context.SaveChanges();
     }
     return(Ok());
 }
 private SupervisorModel MappingSupervisorFromTemp(SupervisorModel supervisor, SupervisorTempModel supervisorTemp)
 {
     supervisor.SV_ID_SUPERVISOR     = supervisorTemp.SV_ID_SUPERVISOR;
     supervisor.SV_ID_AREA           = supervisorTemp.SV_ID_AREA;
     supervisor.CE_ID_EMPRESA        = supervisorTemp.CE_ID_EMPRESA;
     supervisor.SV_COD_SUPERVISOR    = supervisorTemp.SV_COD_SUPERVISOR;
     supervisor.SV_LIMITE_MINIMO     = supervisorTemp.SV_LIMITE_MINIMO;
     supervisor.SV_LIMITE_SUPERIOR   = supervisorTemp.SV_LIMITE_SUPERIOR;
     supervisor.SV_ESTATUS           = supervisorTemp.SV_ESTATUS;
     supervisor.SV_FECHA_CREACION    = supervisorTemp.SV_FECHA_CREACION;
     supervisor.SV_USUARIO_CREACION  = supervisorTemp.SV_USUARIO_CREACION;
     supervisor.SV_FECHA_MOD         = supervisorTemp.SV_FECHA_MOD;
     supervisor.SV_USUARIO_MOD       = supervisorTemp.SV_USUARIO_MOD;
     supervisor.SV_FECHA_APROBACION  = supervisorTemp.SV_FECHA_APROBACION;
     supervisor.SV_USUARIO_APROBADOR = supervisorTemp.SV_USUARIO_APROBADOR;
     return(supervisor);
 }
        public async Task <SupervisorModel> UpdateSupervisorAsync(SupervisorModel model)
        {
            var existing = await _parkRepository.GetSupervisorByIdAsync(model.EmployeeId);

            if (existing == null)
            {
                return(null);
            }

            _mapper.Map(model, existing);

            if (await _parkRepository.SaveChangesAsync())
            {
                return(_mapper.Map <SupervisorModel>(existing));
            }

            return(null);
        }
Exemple #20
0
        public async Task <DBResult> Login(AuthenticationModel model)
        {
            SupervisorModel result    = null;
            bool            hasError  = false;
            string          errorText = "";

            try
            {
                if (ModelState.IsValid || model != null)
                {
                    result = await Authentication.AuthenticateUser(model.Username, model.Password);

                    if (result == null)
                    {
                        return(new DBResult
                        {
                            status = !hasError ? "Success" : "Fail",
                            descripText = "Username/Password is not valid",
                            data = null
                        });
                    }
                }
                else
                {
                    hasError = true;
                }
            }
            catch (Exception e)
            {
                hasError = true;

                return(new DBResult
                {
                    status = !hasError ? "Success" : "Fail",
                    descripText = e.Message.ToString(),
                    data = null
                });
            }
            return(new DBResult {
                status = !hasError ? "Success" : "Fail", descripText = errorText, data = new SupervisorModel {
                    SupervisorId = result.SupervisorId, Name = result.Name, Surname = result.Surname, CemeteryId = result.CemeteryId, UserName = result.UserName, SupervisorPassword = result.SupervisorPassword
                }
            });
        }
Exemple #21
0
 public int updateProfile(SupervisorModel objSupervisorModel)
 {
     try
     {
         return(Execution.ExecuteNonQuery_with_result("sp_employee", new SqlParameter[]
         {
             new SqlParameter("@Command", "SUPERVISORPROFILE"),
             new SqlParameter("@mobile", objSupervisorModel.mobile),
             new SqlParameter("@email", objSupervisorModel.email),
             new SqlParameter("@emergencycontact", objSupervisorModel.emergencyContact),
             new SqlParameter("@profilePic", objSupervisorModel.profilePic),
             new SqlParameter("@userId", objSupervisorModel.userid),
         }));
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
        public UndertakerViewModel(BurialModelOutPut burialOutPut, IBurialService apiBurial)
        {
            _burialOutPut     = burialOutPut;
            _sqLiteConnection = DependencyService.Get <ISQLite>().GetConnection();
            _sqLiteConnection.CreateTable <Burial>();
            if (_burialOutPut.BurialApplication != 0)
            {
                _burialApplication = _burialOutPut.BurialApplication;
                _supervisor        = new SupervisorModel
                {
                    CemeteryId   = burialOutPut.CemeteryId,
                    SupervisorId = burialOutPut.SupervisorId,
                    Name         = burialOutPut.Name,
                    Surname      = burialOutPut.Surname
                };
            }

            _apiBurial = apiBurial;
        }
        public SupervisorModel ScaffoldModel(OpenApiOptions options)
        {
            string supervisorNamespace = Dependencies.Namespace.Supervisor(options.RootNamespace);
            var    model     = new SupervisorModel();
            var    classFile = new ScaffoldedFile
            {
                //var interfaceFile = new ScaffoldedFile();
                Code = Generator.WriteClassCode(options.Document,
                                                options.SupervisorClassName,
                                                options.SupervisorInterfaceName,
                                                supervisorNamespace),
                Path = Dependencies.PathHelper.Supervisor(options.CoreProjectDir, options.SupervisorClassName)
            };

            //interfaceFile.Code = Generator.WriteInterfaceCode(options.Document, options.SupervisorInterfaceName, supervisorNamespace);
            //interfaceFile.Path = Dependencies.PathHelper.Supervisor(options.CoreProjectDir, options.SupervisorInterfaceName);
            model.File = classFile;
            //model.Interface = interfaceFile;
            return(model);
        }
        public async Task <IHttpActionResult> Post([FromBody] SupervisorModel model)
        {
            IdentityUser user = await UserManager.FindByIdAsync(User.Identity.GetUserId());

            model.SV_USUARIO_CREACION = user.Id;
            model.SV_FECHA_CREACION   = DateTime.Now.Date;
            int estadoAprobado = Convert.ToInt32(RegistryStateModel.RegistryState.Aprobado);

            var listSupervisor = supervisorService.GetAll(c => c.CE_ID_EMPRESA == model.CE_ID_EMPRESA &&
                                                          c.SV_ID_AREA == model.SV_ID_AREA &&
                                                          c.SV_ESTATUS == estadoAprobado &&
                                                          c.SV_COD_SUPERVISOR == model.SV_COD_SUPERVISOR, null, includes: c => c.SAX_EMPRESA);

            if (listSupervisor != null & listSupervisor.Count > 0)
            {
                return(BadRequest("No se puede registrar un supervisor dos veces en la misma empresa y área."));
            }
            var supervisor = supervisorService.InsertSupervisor(model);

            return(Ok(supervisor));
        }
        public static async Task <SupervisorModel> AuthenticateUser(string username, string password)
        {
            SupervisorModel result = null;
            var             q      = DataAccess.Context.CEM_LIST_CEMETERY_SUPERVISOR.Where(row => row.UserName == username && row.SupervisorPassword == password).Select(row => new
            {
                Id                 = row.Id,
                Name               = row.Name,
                Surname            = row.Surname,
                CemeteryId         = row.CemeteryId,
                UserName           = row.UserName,
                SupervisorPassword = row.SupervisorPassword
            });
            var qUser = q.FirstOrDefault();
            var user  = qUser;

            if (user != null)
            {
                result = new SupervisorModel {
                    SupervisorId = user.Id, Name = user.Name, Surname = user.Surname, CemeteryId = user.CemeteryId, UserName = user.UserName, SupervisorPassword = user.SupervisorPassword
                };
            }
            return(result);
        }
        private async Task RefreshList(SupervisorModel model)
        {
            IsRefreshing = true;
            if (CrossConnectivity.Current.IsConnected)
            {
                BurialList = await PopulateList(model);

                IsRefreshing = false;
            }
            else
            {
                Device.BeginInvokeOnMainThread(() =>
                {
                    Application.Current.MainPage.DisplayAlert("Error Network Connection",
                                                              "You need to be connected to the internet and restart the application",
                                                              "OK");
                    IsBusy = false;
                });

                IsRefreshing = false;
            }

            IsRefreshing = false;
        }
        public IHttpActionResult GetById(int id)
        {
            SupervisorModel supervisor = null;

            using (var context = new Entities())
            {
                supervisor = context.Supervisor
                             .Where(supervisorItem => supervisorItem.Id == id)
                             .Select(supporterItem => new SupervisorModel()
                {
                    Id           = supporterItem.Id,
                    Name         = supporterItem.Name,
                    password     = supporterItem.password,
                    FirstSurname = supporterItem.FirstSurname,
                    Email        = supporterItem.Email
                }).FirstOrDefault <SupervisorModel>();
            }
            //to do : transform this snippet into a single return
            if (supervisor == null)
            {
                return(NotFound());
            }
            return(Ok(supervisor));
        }
Exemple #28
0
 /// <inheritdoc/>
 public Task OnSupervisorUpdatedAsync(RegistryOperationContextModel context,
                                      SupervisorModel supervisor)
 {
     return(_bus.PublishAsync(Wrap(SupervisorEventType.Updated, context,
                                   supervisor.Id, supervisor)));
 }
        public HttpResponseMessage UpdateProfile([FromBody] SupervisorModel objSupervisorModel)
        {
            IP = System.Configuration.ConfigurationManager.AppSettings["IP"];
            var re      = Request;
            var headers = re.Headers;

            if (headers.Contains("token"))
            {
                token = headers.GetValues("token").First();
            }

            var result = Authtoken.checkToken(token);

            if (result == true)
            {
                if (objSupervisorModel.base64image == null)
                {
                    string pic = objSupervisorModel.profilePic;
                    objSupervisorModel.profilePic = pic.Replace(IP, "");
                    objSupervisorDL.updateProfile(objSupervisorModel);
                    dt = objSupervisorDL.selectbyUserid(objSupervisorModel);

                    foreach (DataRow row in dt.Rows)
                    {
                        string url = dt.Rows[0]["profilePic"].ToString();

                        //need to set value to NewColumn column
                        row["profilePic"] = IP + url;
                    }
                    var resp = Request.CreateResponse <ResponseModel>(HttpStatusCode.OK,
                                                                      new ResponseModel()
                    {
                        message = "Your profile Updated successfully", output = dt, statuscode = Convert.ToInt16(HttpStatusCode.OK)
                    });
                    return(resp);
                }
                else
                {
                    string baseencode = objSupervisorModel.base64image;
                    // Convert Base64 String to byte[]
                    byte[]       imageBytes = Convert.FromBase64String(baseencode);
                    MemoryStream ms         = new MemoryStream(imageBytes, 0, imageBytes.Length);

                    // Convert byte[] to Image
                    string filename = "/uploads/images/profilepics/" + Authtoken.GeneratePin() + AuthorizationToken.GetTimestamp(DateTime.Now) + ".png";
                    ms.Write(imageBytes, 0, imageBytes.Length);
                    System.Drawing.Image image = System.Drawing.Image.FromStream(ms, true);
                    image.Save(HttpContext.Current.Server.MapPath(filename), System.Drawing.Imaging.ImageFormat.Png);
                    objSupervisorModel.profilePic = filename;
                    objSupervisorDL.updateProfile(objSupervisorModel);
                    dt = objSupervisorDL.selectbyUserid(objSupervisorModel);

                    foreach (DataRow row in dt.Rows)
                    {
                        string url = dt.Rows[0]["profilePic"].ToString();

                        //need to set value to NewColumn column
                        row["profilePic"] = IP + url;
                    }

                    var resp = Request.CreateResponse <ResponseModel>(HttpStatusCode.OK,
                                                                      new ResponseModel()
                    {
                        message    = "Your profile Updated successfully",
                        output     = dt,
                        statuscode = Convert.ToInt16(HttpStatusCode.OK)
                    });
                    return(resp);
                }
            }
            else
            {
                var resp = Request.CreateResponse <ResponseModel>(HttpStatusCode.OK, new ResponseModel()
                {
                    message = "UnAuthorized", statuscode = Convert.ToInt16(HttpStatusCode.OK), error = true
                });
                return(resp);
            }
        }
 public void Save(SupervisorModel model)
 {
     Dependencies.FileWriter.WriteFile(model.File);
     //Dependencies.FileWriter.WriteFile(model.Interface);
 }