Beispiel #1
0
        public IHttpActionResult CreateSuperAdmin([FromBody] SuperAdminModel.Format_Create SuperAdmin)
        {
            string logForm = "Form : " + JsonConvert.SerializeObject(SuperAdmin);
            string logAPI  = "[Post] " + Request.RequestUri.ToString();

            if (!ModelState.IsValid || SuperAdmin == null)
            {
                Global._appLogger.Warn(logAPI + " || Input Parameter not expected || " + logForm);
                return(Content(HttpStatusCode.BadRequest, HttpResponseFormat.InvaildData()));
            }

            try
            {
                SuperAdminModel model = new SuperAdminModel();
                int             id    = model.Create(SuperAdmin);
                return(Content(HttpStatusCode.OK, HttpResponseFormat.Success(id)));
            }
            catch (CDSException cdsEx)
            {
                return(Content(HttpStatusCode.BadRequest, CDSException.GetCDSErrorMessageByCode(cdsEx.ErrorId)));
            }
            catch (Exception ex)
            {
                StringBuilder logMessage = LogHelper.BuildExceptionMessage(ex);
                logMessage.AppendLine(logForm);
                Global._appLogger.Error(logAPI + logMessage);

                return(Content(HttpStatusCode.InternalServerError, ex));
            }
        }
Beispiel #2
0
        public IHttpActionResult UpdateFactory(int id, [FromBody] FactoryModel.Format_Update factory)
        {
            string logForm = "Form : " + JsonConvert.SerializeObject(factory);
            string logAPI  = "[Patch] " + Request.RequestUri.ToString();

            if (!ModelState.IsValid || factory == null)
            {
                Global._appLogger.Warn(logAPI + " || Input Parameter not expected || " + logForm);
                return(Content(HttpStatusCode.BadRequest, HttpResponseFormat.InvaildData()));
            }

            FactoryModel factoryModel = new FactoryModel();

            try
            {
                factoryModel.Update(id, factory);
                return(Content(HttpStatusCode.OK, HttpResponseFormat.Success()));
            }
            catch (CDSException cdsEx)
            {
                return(Content(HttpStatusCode.BadRequest, CDSException.GetCDSErrorMessageByCode(cdsEx.ErrorId)));
            }
            catch (Exception ex)
            {
                StringBuilder logMessage = LogHelper.BuildExceptionMessage(ex);
                logMessage.AppendLine(logForm);
                Global._appLogger.Error(logAPI + logMessage);

                return(Content(HttpStatusCode.InternalServerError, ex));
            }
        }
Beispiel #3
0
        public IHttpActionResult UpdateSubscription(int id, int subscriptionId, [FromBody] CompanyInSubscriptionPlanModel.Format_Update dataModel)
        {
            string logForm = "Form : " + JsonConvert.SerializeObject(dataModel);
            string logAPI  = "[Put] " + Request.RequestUri.ToString();

            if (!ModelState.IsValid || dataModel == null)
            {
                Global._appLogger.Warn(logAPI + " || Input Parameter not expected || " + logForm);
                return(Content(HttpStatusCode.BadRequest, HttpResponseFormat.InvaildData()));
            }

            try
            {
                CompanyInSubscriptionPlanModel model = new CompanyInSubscriptionPlanModel();
                model.Update(id, subscriptionId, dataModel);
                //RedisCacheHelper.DeleteCompanyCache(id);
                return(Content(HttpStatusCode.OK, HttpResponseFormat.Success()));
            }
            catch (CDSException cdsEx)
            {
                return(Content(HttpStatusCode.BadRequest, CDSException.GetCDSErrorMessageByCode(cdsEx.ErrorId)));
            }
            catch (Exception ex)
            {
                StringBuilder logMessage = LogHelper.BuildExceptionMessage(ex);
                logMessage.AppendLine(logForm);
                Global._appLogger.Error(logAPI + logMessage);

                return(Content(HttpStatusCode.InternalServerError, ex));
            }
        }
Beispiel #4
0
        public IHttpActionResult CreateCompany(CompanyModel.Format_Create company)
        {
            string logForm = "Form : " + JsonConvert.SerializeObject(company);
            string logAPI  = "[Post] " + Request.RequestUri.ToString();

            if (!ModelState.IsValid || company == null)
            {
                Global._appLogger.Warn(logAPI + " || Input Parameter not expected || " + logForm);
                return(Content(HttpStatusCode.BadRequest, HttpResponseFormat.InvaildData()));
            }

            try
            {
                CompanyModel companyModel = new CompanyModel();
                int          id           = companyModel.Create(company);
                return(Content(HttpStatusCode.OK, HttpResponseFormat.Success(id)));
            }
            catch (Exception ex)
            {
                StringBuilder logMessage = LogHelper.BuildExceptionMessage(ex);
                logMessage.AppendLine(logForm);
                Global._appLogger.Error(logAPI + logMessage);

                return(Content(HttpStatusCode.InternalServerError, ex));
            }
        }
        public IHttpActionResult EditRolesByEmployeeId(int id, [FromBody] EmployeeInRoleModel.Format_Update dataModel)
        {
            string logForm = "Form : " + JsonConvert.SerializeObject(dataModel);
            string logAPI  = "[Put] " + Request.RequestUri.ToString();

            try
            {
                EmployeeInRoleModel model = new EmployeeInRoleModel();
                model.DeleteAllByEmployeeId(id);

                if (dataModel != null && dataModel.UserRoleIdList.Count > 0)
                {
                    model.CreateManyByEmployeeId(id, dataModel.UserRoleIdList);
                }
                return(Content(HttpStatusCode.OK, HttpResponseFormat.Success()));
            }
            catch (CDSException cdsEx)
            {
                return(Content(HttpStatusCode.BadRequest, CDSException.GetCDSErrorMessageByCode(cdsEx.ErrorId)));
            }
            catch (Exception ex)
            {
                StringBuilder logMessage = LogHelper.BuildExceptionMessage(ex);
                logMessage.AppendLine(logForm);
                Global._appLogger.Error(logAPI + logMessage);

                return(Content(HttpStatusCode.InternalServerError, ex));
            }
        }
        public IHttpActionResult ResetEmployeePassword(int id, [FromBody] PasswordModel.Format_Reset dataModel)
        {
            string logForm = "Form : " + JsonConvert.SerializeObject(dataModel);
            string logAPI  = "[Put] " + Request.RequestUri.ToString();

            if (!ModelState.IsValid || dataModel == null)
            {
                Global._appLogger.Warn(logAPI + " || Input Parameter not expected || " + logForm);
                return(Content(HttpStatusCode.BadRequest, HttpResponseFormat.InvaildData()));
            }

            try
            {
                EmployeeModel model = new EmployeeModel();
                model.ResetPassword(id, dataModel);
                return(Content(HttpStatusCode.OK, HttpResponseFormat.Success()));
            }
            catch (CDSException cdsEx)
            {
                return(Content(HttpStatusCode.BadRequest, CDSException.GetCDSErrorMessageByCode(cdsEx.ErrorId)));
            }
            catch (Exception ex)
            {
                StringBuilder logMessage = LogHelper.BuildExceptionMessage(ex);
                logMessage.AppendLine(logForm);
                Global._appLogger.Error(logAPI + logMessage);

                return(Content(HttpStatusCode.InternalServerError, ex));
            }
        }
Beispiel #7
0
        public IHttpActionResult DeleteCompany([FromUri] int companyId, [FromBody] BackendTaskModel.Format_Base dataModel)
        {
            string logForm = "Form : " + JsonConvert.SerializeObject(dataModel);
            string logAPI  = "[Delete] " + Request.RequestUri.ToString();

            if (!ModelState.IsValid || dataModel == null)
            {
                Global._appLogger.Warn(logAPI + " || Input Parameter not expected || " + logForm);
                return(Content(HttpStatusCode.BadRequest, HttpResponseFormat.InvaildData()));
            }

            try
            {
                BackendTaskModel model = new BackendTaskModel();
                model.DeleteCompanyCosmosDBCollection(companyId, dataModel);
                return(Content(HttpStatusCode.OK, HttpResponseFormat.Success()));
            }
            catch (CDSException cdsEx)
            {
                return(Content(HttpStatusCode.BadRequest, CDSException.GetCDSErrorMessageByCode(cdsEx.ErrorId)));
            }
            catch (Exception ex)
            {
                StringBuilder logMessage = LogHelper.BuildExceptionMessage(ex);
                logMessage.AppendLine(logForm);
                Global._appLogger.Error(logAPI + logMessage);

                return(Content(HttpStatusCode.InternalServerError, ex));
            }
        }
Beispiel #8
0
 public IHttpActionResult DeleteSuperAdmin(int id)
 {
     try
     {
         SuperAdminModel model = new SuperAdminModel();
         model.DeleteById(id);
         return(Content(HttpStatusCode.OK, HttpResponseFormat.Success()));
     }
     catch (CDSException cdsEx)
     {
         return(Content(HttpStatusCode.BadRequest, CDSException.GetCDSErrorMessageByCode(cdsEx.ErrorId)));
     }
     catch (Exception ex)
     {
         string        logAPI     = "[Delete] " + Request.RequestUri.ToString();
         StringBuilder logMessage = LogHelper.BuildExceptionMessage(ex);
         Global._appLogger.Error(logAPI + logMessage);
         return(Content(HttpStatusCode.InternalServerError, ex));
     }
 }
Beispiel #9
0
 public IHttpActionResult AttachEquipmentClassMessageCatalog(int id, EquipmentClassMessageCatalogModel.Format_Update dataModel)
 {
     try
     {
         EquipmentClassMessageCatalogModel model = new EquipmentClassMessageCatalogModel();
         model.UpdateByEquipmentClassId(id, dataModel);
         return(Content(HttpStatusCode.OK, HttpResponseFormat.Success()));
     }
     catch (CDSException cdsEx)
     {
         return(Content(HttpStatusCode.BadRequest, CDSException.GetCDSErrorMessageByCode(cdsEx.ErrorId)));
     }
     catch (Exception ex)
     {
         string        logAPI     = "[Delete] " + Request.RequestUri.ToString();
         StringBuilder logMessage = LogHelper.BuildExceptionMessage(ex);
         Global._appLogger.Error(logAPI + logMessage);
         return(Content(HttpStatusCode.InternalServerError, ex));
     }
 }
Beispiel #10
0
        public async Task <IHttpActionResult> UploadLogoFile(int id)
        {
            string logAPI = "[Put] " + Request.RequestUri.ToString();

            // Check if the request contains multipart/form-data.
            if (!Request.Content.IsMimeMultipartContent())
            {
                return(Content(HttpStatusCode.UnsupportedMediaType, HttpResponseFormat.UnsupportedMediaType()));
            }

            CompanyModel companyModel = new CompanyModel();
            //FileHelper fileHelper = new FileHelper();
            BlobStorageHelper storageHelper = new BlobStorageHelper(Global._systemStorageName, Global._systemStorageKey, Global._imageStorageContainer);
            string            root          = Path.GetTempPath();
            var provider = new MultipartFormDataStreamProvider(root);

            try
            {
                CompanyModel.Format_Detail company = companyModel.GetById(id);
            }
            catch (CDSException cdsEx)
            {
                return(Content(HttpStatusCode.BadRequest, CDSException.GetCDSErrorMessageByCode(cdsEx.ErrorId)));
            }
            catch (Exception ex)
            {
                StringBuilder logMessage = LogHelper.BuildExceptionMessage(ex);
                Global._appLogger.Error(logAPI + logMessage);

                return(Content(HttpStatusCode.InternalServerError, ex));
            }

            try
            {
                // Read the form data.
                string LogoAbsoluteUri = "", IconAbsoluteUri = "";
                await Request.Content.ReadAsMultipartAsync(provider);

                //FileData
                foreach (MultipartFileData fileData in provider.FileData)
                {
                    string fileExtension = Path.GetExtension(fileData.Headers.ContentDisposition.FileName.Replace("\"", "").ToLower());
                    if (fileExtension.Equals(".jpg", StringComparison.InvariantCultureIgnoreCase) ||
                        fileExtension.Equals(".jpeg", StringComparison.InvariantCultureIgnoreCase) ||
                        fileExtension.Equals(".png", StringComparison.InvariantCultureIgnoreCase))
                    {
                        ImageHelper imageHelper    = new ImageHelper();
                        string      uploadFilePath = String.Format("company-{0}", id);

                        LogoAbsoluteUri = imageHelper.PublishImage(fileData.LocalFileName, storageHelper, uploadFilePath, Global._companyLogoWidthHeight, Global._imageBgColor, Global._imageFormat);
                        IconAbsoluteUri = imageHelper.PublishImage(fileData.LocalFileName, storageHelper, uploadFilePath, Global._companyIconWidthHeight, Global._imageBgColor, Global._imageFormat);
                    }
                    else
                    {
                        return(Content(HttpStatusCode.BadRequest, HttpResponseFormat.Error("Unsupport File Type.")));
                    }
                }

                if (LogoAbsoluteUri.Equals(""))
                {
                    return(Content(HttpStatusCode.BadRequest, HttpResponseFormat.Error("File is empty or wrong extension name.")));
                }

                //Edit company logo path
                companyModel.UpdateLogoURL(id, LogoAbsoluteUri, IconAbsoluteUri);
                //RedisCacheHelper.DeleteCompanyCache(id);
                return(Content(HttpStatusCode.OK, HttpResponseFormat.Success(LogoAbsoluteUri)));
            }
            catch (CDSException cdsEx)
            {
                return(Content(HttpStatusCode.BadRequest, CDSException.GetCDSErrorMessageByCode(cdsEx.ErrorId)));
            }
            catch (System.Exception ex)
            {
                StringBuilder logMessage = LogHelper.BuildExceptionMessage(ex);
                Global._appLogger.Error(logAPI + logMessage);

                return(Content(HttpStatusCode.InternalServerError, ex));
            }
        }