public async Task <RouteVersion> GetRouteVersion(string routeId)
{
RouteVersion routeVersion = new RouteVersion();
try
{
var response = await _serverRequest.HttpRequestGet($"/api/route/{routeId}/version", _authToken);
LastHttpStatusCode = _serverRequest.GetLastStatusCode();
var deserializedValue = JsonConvert.DeserializeObject <List <RouteVersion> >(response);
if (deserializedValue.Any())
{
routeVersion = deserializedValue.FirstOrDefault();
}
}
catch (Exception e)
{
HandleError.Process("RoutesApiRequest", "GetRouteVersion", e, false);
}
return(routeVersion);
}
public static void Perform( HttpWebRequest request,
ID2LUserContext userContext,
HandleResponse responseHandler,
HandleError errorHandler,
int retryAttempts = 0)
{
try {
using (var response = (HttpWebResponse) request.GetResponse()) {
using (var stream = response.GetResponseStream()) {
using (var reader = new StreamReader( stream, Encoding.UTF8 )) {
string responseBody = reader.ReadToEnd();
responseHandler( responseBody );
}
}
}
}
catch (WebException we) {
var exceptionWrapper = new D2LWebException( we );
var result = userContext.InterpretResult( exceptionWrapper );
switch (result) {
case RequestResult.RESULT_INVALID_TIMESTAMP:
if (retryAttempts > 0) {
// re-create the request to ensure the new url accounts for calculated skew
Uri uri = userContext.CreateAuthenticatedUri( request.RequestUri.AbsoluteUri,
request.Method );
request = (HttpWebRequest) WebRequest.Create( uri );
Perform( request, userContext, responseHandler, errorHandler, retryAttempts - 1 );
}
break;
}
errorHandler( result, request.RequestUri );
}
catch (ArgumentException) {
errorHandler( RequestResult.RESULT_UNKNOWN, request.RequestUri );
}
}
private async Task <bool> IsValidLogin()
{
if (string.IsNullOrEmpty(Username) || Password.Length <= 0)
{
return(false);
}
using (var client = new Vndb(Username, Password))
{
var users = await client.GetUserAsync(VndbFilters.Username.Equals(Username));
if (users == null)
{
HandleError.HandleErrors(client.GetLastError(), 0);
return(false);
}
else
{
_userId = users.Items[0].Id;
return(true);
}
}
}
public IActionResult AddTariff(TariffModel model)
{
PermissionRange permissionRange;
ICurrentUser _user = PermissionExtention.GetUserMenuPermission(currentUser, Menu.settingTariff);
permissionRange = PermissionExtention.GetPermissionRange(_user.UserMenuPermission.Write);
if (permissionRange == PermissionRange.None)
{
return(BadRequest(new ResultHandle {
Status = false, Message = stringLocalizer[LanguageSub.DO_NOT_HAVE_PERMISSION].Value
}));
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
var checkData = tariffService.CheckExistsDataTariff(model);
if (!checkData.Success)
{
return(Ok(new ResultHandle {
Status = checkData.Success, Message = checkData.Exception.Message.ToString(), Data = checkData.Code
}));
}
var hs = tariffService.AddTariff(model);
var message = HandleError.GetMessage(hs, Crud.Insert);
ResultHandle result = new ResultHandle {
Status = hs.Success, Message = stringLocalizer[message].Value, Data = model
};
return(Ok(result));
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
using (UserDialogs.Instance.Loading(CommonResource.Login_AuthorizationProcess, () => { }, "", true, MaskType.Gradient))
{
try
{
// Convert Android.Net.Url to Uri
var uri = new Uri(Intent.Data.ToString());
// Load redirectUrl page
AuthenticationState.Authenticator?.OnPageLoading(uri);
}
catch (Exception e)
{
HandleError.Process("GoogleAuthInterceptor", "OnCreate load redirect page", e, false);
}
//Костыль для обхода ошибки
//https://github.com/xamarin/Xamarin.Auth/issues/275
try
{
var intent = new Intent(this, typeof(MainActivity));
intent.SetFlags(ActivityFlags.ClearTop | ActivityFlags.SingleTop);
StartActivity(intent);
}
catch (Exception e)
{
HandleError.Process("GoogleAuthInterceptor", "OnCreate StartActivity", e, false);
}
//Костыль для обхода ошибки
}
Finish();
return;
}
private async Task <bool> TryToSendFileAsync(string pathToMediaFile, string nameMediafile, string routePointId, string routePointMediaObjectId)
{
bool result = false;
try
{
using (Stream image = File.Open(pathToMediaFile, FileMode.Open))
{
using (HttpContent content = new StreamContent(image))
{
content.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "file", FileName = nameMediafile
};
content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _authToken);
using (var formData = new MultipartFormDataContent())
{
formData.Add(content);
HttpResponseMessage response = await client.PostAsync($"{ this._hostUrl }/routepointmediaobjects/{ routePointId }/{ routePointMediaObjectId }/uploadfile", formData);
LastHttpStatusCode = response.StatusCode;
result = response.IsSuccessStatusCode;
}
}
}
}
}
catch (Exception e)
{
HandleError.Process("RoutePointMediaObjectApiRequest", "TryToSendFileAsync", e, false);
result = false;
}
return(result);
}
public IActionResult Insert(SysAuthorizationModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (CheckExistsDateRangeAuthorization(model))
{
return(BadRequest(new ResultHandle {
Status = false, Message = stringLocalizer[SystemLanguageSub.MSG_ITEM_SIMILAR_AUTHORIZATION].Value
}));
}
if (model.EndDate != null)
{
if (model.StartDate.Date > model.EndDate.Value.Date)
{
return(BadRequest(new ResultHandle {
Status = false, Message = stringLocalizer[SystemLanguageSub.MSG_ITEM_EXPIRATION_DATE_GREATER_OR_EQUAL_EFFECTIVE_DATE].Value
}));
}
}
var hs = sysAuthorizationService.Insert(model);
var message = HandleError.GetMessage(hs, Crud.Insert);
ResultHandle result = new ResultHandle {
Status = hs.Success, Message = stringLocalizer[message].Value, Data = model
};
if (!hs.Success)
{
return(Ok(result));
}
return(Ok(result));
}
private async void button1_Click(object sender, EventArgs e)
{
string catalogName = tbCatalogName.Text;
bool isValid = true;
if (string.IsNullOrWhiteSpace(catalogName))
{
errorProvider.SetError(tbCatalogName, "Bat buoc");
isValid = false;
}
else
{
errorProvider.SetError(tbCatalogName, null);
}
if (!isValid)
{
return;
}
var res = await CatalogController.CreateCatalog(new Catalog
{
CatalogName = catalogName,
});
if (!res.IsSuccess)
{
Notification.Error(HandleError <CatalogErrorMessage> .GetErrorString(res.Messages));
return;
}
Notification.Success("Success");
_catalogListPage.renderCatalogs();
this.Hide();
}
public bool SaveTrack(string routeId, ViewTrackPlace[] trackResponsePlaces)
{
bool result = false;
try
{
RealmInstance.Write(() =>
{
RealmInstance.RemoveRange(RealmInstance.All <RouteTrackPlace>()
.Where(p => p.RouteTrackId.Equals(routeId)));
foreach (var place in trackResponsePlaces)
{
RealmInstance.Add(new RouteTrackPlace()
{
RouteTrackId = routeId,
Id = place.Id,
Name = place.Name,
Description = place.Description,
DateTimeBegin = place.DateTimeBegin,
DateTimeEnd = place.DateTimeEnd,
Latitude = place.Latitude,
Longitude = place.Longitude,
Address = place.Address,
Category = place.Category,
Distance = place.Distance,
Elevation = place.Elevation
});
}
});
result = true;
}
catch (Exception e)
{
HandleError.Process("TrackFileManager", "SaveTrack", e, false);
}
return(result);
}
public IActionResult Put(string id, CatPartnerEditModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (!String.IsNullOrEmpty(model.InternalReferenceNo))
{
model.AccountNo = model.TaxCode + "." + model.InternalReferenceNo;
}
else
{
model.AccountNo = model.TaxCode;
}
var checkExistMessage = CheckExist(id, model);
if (checkExistMessage.Length > 0)
{
return(BadRequest(new ResultHandle {
Status = false, Message = checkExistMessage
}));
}
var partner = mapper.Map <CatPartnerModel>(model);
partner.Id = id;
var hs = catPartnerService.Update(partner);
var message = HandleError.GetMessage(hs, Crud.Update);
ResultHandle result = new ResultHandle {
Status = hs.Success, Message = stringLocalizer[message].Value
};
if (!hs.Success)
{
return(BadRequest(result));
}
return(Ok(result));
}
public IActionResult Delete(int id)
{
var item = sysAuthorizationService.GetAuthorizationById(id);
if (item.Active == true)
{
return(BadRequest(new ResultHandle {
Status = false, Message = stringLocalizer[SystemLanguageSub.MSG_ITEM_IS_ACTIVE_NOT_ALLOW_DELETED].Value
}));
}
var hs = sysAuthorizationService.Delete(x => x.Id == id);
var message = HandleError.GetMessage(hs, Crud.Update);
ResultHandle result = new ResultHandle {
Status = hs.Success, Message = stringLocalizer[message].Value
};
if (!hs.Success)
{
return(BadRequest(result));
}
return(Ok(result));
}
public IEnumerable <ViewRoutePoint> GetPointsByRouteId(string routeId, bool withDeleted = false)
{
List <ViewRoutePoint> collection = new List <ViewRoutePoint>();
try
{
var collectionRealm = withDeleted
? RealmInstance.All <RoutePoint>().Where(point => point.RouteId == routeId)
.OrderBy(point => point.CreateDate)
: RealmInstance.All <RoutePoint>().Where(point => point.RouteId == routeId && !point.IsDeleted)
.OrderBy(point => point.CreateDate);
foreach (var item in collectionRealm)
{
collection.Add(new ViewRoutePoint(item.RouteId, item.RoutePointId));
}
}
catch (Exception e)
{
collection = new List <ViewRoutePoint>();
HandleError.Process("RoutePointManager", "GetPointsByRouteId", e, false);
}
return(collection);
}
public IActionResult AddAndUpdate(string partnerId, List <DL.Models.CatPartnerChargeModel> charges)
{
ResultHandle result = new ResultHandle();
var group = charges.GroupBy(x => new { x.ChargeId, x.PartnerId });
if (group.Any(x => x.Count() > 1))
{
result.Status = false;
result.Message = "Duplicate charge";
return(BadRequest(result));
}
HandleState hs = catPartnerChargeService.AddAndUpdate(partnerId, charges);
var message = HandleError.GetMessage(hs, Crud.Insert);
result = new ResultHandle {
Status = hs.Success, Message = stringLocalizer[message].Value
};
if (!hs.Success)
{
return(BadRequest(result));
}
return(Ok(result));
}
public async Task <bool> SetEmotionAsync(string RouteId, bool Emotion)
{
bool result = false;
try
{
var emotionStructure = new
{
EmotionNum = Emotion ? 1 : 0
};
string body = JsonConvert.SerializeObject(emotionStructure);
ApiRequest api = new ApiRequest();
await api.HttpRequestPOST($"{this._hostUrl}/likes/{RouteId}/addemotion", body, _authToken);
LastHttpStatusCode = api.LastHttpStatusCode;
result = LastHttpStatusCode == HttpStatusCode.OK;
}
catch (Exception e)
{
HandleError.Process("RoutesApiRequest", "SetEmotionAsync", e, false);
}
return(result);
}
private Task HandleExceptionsAsync(HttpContext context, Exception ex)
{
context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
context.Response.ContentType = "application/json";
try
{
ErrorType errorType = GenerateErrorHandler(ex);
if (errorType.IsError())
{
context.Response.StatusCode = errorType.Get().StatusCode;
return(errorType.GenericResponse(context,
ErrorDetailResponseFactory.CreateKnownErrorDetails(ex.Message, errorType.Get().ResultCode, errorType.Get().Title)));
}
return(errorType.GenericResponse(context,
ErrorDetailResponseFactory.CreateGenericErrorDetails(ex.Message, context.Response.StatusCode, ex)));
}
catch (Exception e)
{
return(HandleError.WithDefaultJsonConverter(context,
ErrorDetailResponseFactory.CreateGenericErrorDetails(e.Message, context.Response.StatusCode, e)));
}
}
public IActionResult AddNew(CustomsDeclarationModel model)
{
ICurrentUser _user = PermissionExtention.GetUserMenuPermission(currentUser, Menu.opsCustomClearance);
var code = CheckForbitUpdate(_user.UserMenuPermission.Write);
if (code == 403)
{
return(Forbid());
}
var existedMessage = CheckExist(model, model.Id);
if (existedMessage != null)
{
return(BadRequest(new ResultHandle {
Status = false, Message = existedMessage
}));
}
model.DatetimeCreated = DateTime.Now;
model.DatetimeModified = DateTime.Now;
model.UserCreated = model.UserModified = currentUser.UserID;
model.Source = OperationConstants.FromEFMS;
model.GroupId = currentUser.GroupId;
model.DepartmentId = currentUser.DepartmentId;
model.OfficeId = currentUser.OfficeID;
model.CompanyId = currentUser.CompanyID;
var hs = customsDeclarationService.Add(model);
var message = HandleError.GetMessage(hs, Crud.Insert);
ResultHandle result = new ResultHandle {
Status = hs.Success, Message = stringLocalizer[message].Value
};
if (!hs.Success)
{
return(BadRequest(result));
}
return(Ok(result));
}
private async void button1_Click(object sender, EventArgs e)
{
_error.SetError(tbName, string.IsNullOrWhiteSpace(tbName.Text) ? activeError("Bắt buộc") : null);
_error.SetError(tbEmail, string.IsNullOrWhiteSpace(tbEmail.Text) ? activeError("Bắt buộc") : null);
_error.SetError(tbPhone, string.IsNullOrWhiteSpace(tbPhone.Text) ? activeError("Bắt buộc") : null);
_error.SetError(tbAddress, string.IsNullOrWhiteSpace(tbAddress.Text) ? activeError("Bắt buộc") : null);
if (isError)
{
isError = false;
return;
}
var res = await UserController.UpdateUser(_user.Id, new User
{
FullName = tbName.Text,
Address = tbAddress.Text,
Email = tbEmail.Text,
RoleName = _role,
PhoneNumber = tbPhone.Text,
});
if (res == null)
{
return;
}
if (!res.IsSuccess)
{
Notification.Error(HandleError <UserErrorMessage> .GetErrorString(res.Messages));
}
else
{
Notification.Success("Success");
_callback();
Close();
}
}
public IActionResult Put(short id, CatCommodityGroupEditModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var checkExistMessage = CheckExist(id, model);
if (checkExistMessage.Length > 0)
{
return(BadRequest(new ResultHandle {
Status = false, Message = checkExistMessage
}));
}
var commonityGroup = mapper.Map <CatCommodityGroupModel>(model);
commonityGroup.UserModified = currentUser.UserID;
commonityGroup.DatetimeModified = DateTime.Now;
commonityGroup.Id = id;
if (commonityGroup.Active == false)
{
commonityGroup.InactiveOn = DateTime.Now;
}
var hs = catComonityGroupService.Update(commonityGroup, x => x.Id == id);
var message = HandleError.GetMessage(hs, Crud.Update);
ResultHandle result = new ResultHandle {
Status = hs.Success, Message = stringLocalizer[message].Value
};
if (!hs.Success)
{
return(BadRequest(result));
}
catComonityGroupService.ClearCache();
catComonityGroupService.Get();
return(Ok(result));
}
public IActionResult Delete(Guid id)
{
var permission = permissionGeneralService.Get(x => x.Id == id);
if (permission != null && permission.FirstOrDefault(x => x.Active == true) != null)
{
return(BadRequest(new ResultHandle {
Status = false, Message = stringLocalizer[SystemLanguageSub.MSG_ITEM_IS_ACTIVE_NOT_ALLOW_DELETED].Value
}));
}
var hs = permissionGeneralService.Delete(id);
var message = HandleError.GetMessage(hs, Crud.Delete);
ResultHandle result = new ResultHandle {
Status = hs.Success, Message = stringLocalizer[message].Value
};
if (!hs.Success)
{
return(Ok(result));
}
return(Ok(result));
}
public async Task <(bool result, string newMediaId)> TakePhotoAsync(double latitude, double longitude)
{
bool takePhotoResult = false;
string mediaId = Guid.NewGuid().ToString();
string photoName = ImagePathManager.GetMediaFilename(mediaId, MediaObjectTypeEnum.Image);
MediaFile file;
PermissionManager permissions = new PermissionManager();
if (await permissions.PermissionGrantedAsync(Plugin.Permissions.Abstractions.Permission.Photos, CommonResource.RoutePoint_RightNeedToTakePhoto))
{
try
{
file = await CrossMedia.Current.TakePhotoAsync(new StoreCameraMediaOptions
{
Location = new Plugin.Media.Abstractions.Location()
{
Latitude = latitude, Longitude = longitude, Timestamp = DateTime.Now
},
Directory = string.Empty,
Name = photoName,
SaveToAlbum = true,
PhotoSize = PhotoSize.Full,
CompressionQuality = 40//так же соответствует параметрам качества при выборе фото
});
takePhotoResult = file != null;
}
catch (Exception e)
{
HandleError.Process("ImageManager", "TakePhoto", e, false);
}
}
return(takePhotoResult, mediaId);
}
public IActionResult Update(CatChargeAddOrUpdateModel model)
{
ICurrentUser _user = PermissionExtention.GetUserMenuPermission(currentUser, Menu.catCharge);
PermissionRange permissionRange = PermissionExtention.GetPermissionRange(_user.UserMenuPermission.Write);
if (permissionRange == PermissionRange.None || !catChargeService.CheckAllowPermissionAction(model.Charge.Id, permissionRange))
{
return(BadRequest(new ResultHandle {
Status = false, Message = stringLocalizer[LanguageSub.DO_NOT_HAVE_PERMISSION].Value
}));
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
var checkExistMessage = CheckExist(model.Charge.Id, model);
if (checkExistMessage.Length > 0)
{
return(BadRequest(new ResultHandle {
Status = false, Message = checkExistMessage
}));
}
var hs = catChargeService.UpdateCharge(model);
var message = HandleError.GetMessage(hs, Crud.Update);
ResultHandle result = new ResultHandle {
Status = hs.Success, Message = stringLocalizer[message].Value
};
if (!hs.Success)
{
return(BadRequest(result));
}
return(Ok(result));
}
public IActionResult Delete(Guid id, string partnerId)
{
var hs = catSaleManService.Delete(id);
var message = HandleError.GetMessage(hs, Crud.Delete);
ResultHandle result = new ResultHandle {
Status = hs.Success, Message = stringLocalizer[message].Value
};
if (hs.Success)
{
var objPartner = partnerService.Get(x => x.Id == partnerId).FirstOrDefault();
objPartner.SalePersonId = catSaleManService.Get(x => x.PartnerId == partnerId)?.OrderBy(x => x.CreateDate).FirstOrDefault().SaleManId.ToString();
var hsPartner = partnerService.Update(objPartner, x => x.Id == partnerId);
if (!hsPartner.Success)
{
return(BadRequest());
}
}
if (!hs.Success)
{
return(BadRequest(result));
}
return(Ok(result));
}
public async Task <string> UpdateHash(string routeId)
{
string serverHash = String.Empty;
try
{
var response = await _serverRequest.HttpRequestPost($"/api/v2/routes/{routeId}/updatehash", _authToken, String.Empty);
LastHttpStatusCode = _serverRequest.GetLastStatusCode();
if (LastHttpStatusCode == HttpStatusCode.OK)
{
serverHash = response;
}
else
{
throw new HttpRequestException(LastHttpStatusCode.ToString());
}
}
catch (Exception e)
{
HandleError.Process("RoutesApiRequest", "UpdateHash", e, false);
}
return(serverHash);
}
public IActionResult Delete(Guid id)
{
ICurrentUser _user = PermissionExtention.GetUserMenuPermission(currentUser, Menu.catCharge);
PermissionRange permissionRange = PermissionExtention.GetPermissionRange(_user.UserMenuPermission.Delete);
if (!catChargeService.CheckAllowPermissionAction(id, permissionRange))
{
return(BadRequest(new ResultHandle {
Status = false, Message = stringLocalizer[LanguageSub.DO_NOT_HAVE_PERMISSION].Value
}));
}
var hs = catChargeService.DeleteCharge(id);
var message = HandleError.GetMessage(hs, Crud.Delete);
ResultHandle result = new ResultHandle {
Status = hs.Success, Message = stringLocalizer[message].Value
};
if (!hs.Success)
{
return(BadRequest(result));
}
return(Ok(result));
}
public IActionResult UpdateSOA(AcctSoaModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var isAllowUpdate = acctSOAService.CheckUpdatePermission(model.Soano);
if (isAllowUpdate == false)
{
return(BadRequest(new ResultHandle {
Status = false, Message = stringLocalizer[LanguageSub.DO_NOT_HAVE_PERMISSION].Value
}));
}
var hs = acctSOAService.UpdateSOA(model);
if (hs.Code == 403)
{
return(BadRequest(new ResultHandle {
Status = false, Message = stringLocalizer[LanguageSub.DO_NOT_HAVE_PERMISSION].Value
}));
}
var message = HandleError.GetMessage(hs, Crud.Update);
ResultHandle result = new ResultHandle {
Status = hs.Success, Message = stringLocalizer[message].Value, Data = model
};
if (!hs.Success)
{
return(BadRequest(result));
}
return(Ok(result));
}
public async Task <bool> HttpRequestPostFile(string relativeUrl, string authToken, byte[] fileBytes, string filename)
{
bool result = false;
string url = new Uri(_apiBaseUri, relativeUrl).AbsoluteUri;
_logger.AddStringEvent($"POST file start:{url}");
DateTime dStart = DateTime.Now;
fillHeaders(authToken);
try
{
using (var content = new ByteArrayContent(fileBytes))
{
content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
content.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "file", FileName = filename
};
using (var formData = new MultipartFormDataContent())
{
formData.Add(content);
HttpResponseMessage response = await _httpClient.PostAsync(url, formData);
_lastHttpStatusCode = response.StatusCode;
result = _lastHttpStatusCode == HttpStatusCode.OK;
}
}
}
catch (Exception e)
{
_logger.AddStringEvent($"POST file error:[{url}], delay [{(dStart - DateTime.Now).Milliseconds}], error [{e.Message}]");
HandleError.Process("ServerRequest", "HttpRequestPostFile", e, false);
}
_logger.AddStringEvent($"POST file end:[{url}], delay [{(dStart - DateTime.Now).Milliseconds}]");
return(result);
}
public bool Save(ViewLocalFile viewItem)
{
bool result = false;
try
{
RealmInstance.Write(() =>
{
var dbObject = !string.IsNullOrEmpty(viewItem.Id) ? RealmInstance.Find <LocalFile>(viewItem.Id) : null;
if (null == dbObject)
{
dbObject = string.IsNullOrEmpty(viewItem.Id) ? new LocalFile() : new LocalFile()
{
LocalFileId = viewItem.Id
};
RealmInstance.Add(dbObject);
}
dbObject.Address = viewItem.Address;
dbObject.Country = viewItem.Country;
dbObject.FileNameDate = viewItem.FileNameDate;
dbObject.CreateDate = viewItem.CreateDate;
dbObject.ImagePreviewFileName = viewItem.ImagePreviewFileName;
dbObject.Latitude = viewItem.Latitude;
dbObject.Longitude = viewItem.Longitude;
dbObject.SourceFileName = viewItem.SourceFileName;
dbObject.SourcePath = viewItem.SourcePath;
dbObject.Processed = viewItem.Processed;
});
result = true;
}
catch (Exception e)
{
HandleError.Process("LocalFileCacheManager", "Save", e, false);
}
return(result);
}
public IActionResult Update(SysUserModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var userCurrent = sysUserService.GetUserById(model.Id);
var existedMessage = CheckExistCode(model.SysEmployeeModel.StaffCode, userCurrent.EmployeeId);
var existedName = CheckExistUserName(model.Username, model.Id);
if (existedMessage.Length > 0)
{
return(BadRequest(new ResultHandle {
Status = false, Message = existedMessage
}));
}
if (existedName.Length > 0)
{
return(BadRequest(new ResultHandle {
Status = false, Message = existedName
}));
}
var employeeCurrent = sysEmployeeService.Get(x => x.Id == userCurrent.EmployeeId).FirstOrDefault();
var hsEmployee = new HandleState();
if (employeeCurrent != null)
{
model.SysEmployeeModel.Id = employeeCurrent.Id;
model.SysEmployeeModel.UserModified = currentUser.UserID;
model.SysEmployeeModel.DatetimeModified = DateTime.Now;
model.SysEmployeeModel.Active = true;
hsEmployee = sysEmployeeService.Update(model.SysEmployeeModel);
}
else
{
model.SysEmployeeModel.Id = Guid.NewGuid().ToString();
model.SysEmployeeModel.UserCreated = model.SysEmployeeModel.UserModified = currentUser.UserID;
model.SysEmployeeModel.DatetimeModified = DateTime.Now;
model.SysEmployeeModel.Active = true;
hsEmployee = sysEmployeeService.Insert(model.SysEmployeeModel);
}
var messageEmployee = HandleError.GetMessage(hsEmployee, Crud.Update);
ResultHandle resultEmployee = new ResultHandle {
Status = hsEmployee.Success, Message = stringLocalizer[messageEmployee].Value
};
if (hsEmployee.Success)
{
model.UserModified = currentUser.UserID;
model.DatetimeModified = DateTime.Now;
model.Password = userCurrent.Password;
model.EmployeeId = model.SysEmployeeModel.Id;
model.UserCreated = userCurrent.UserCreated;
model.DatetimeCreated = userCurrent.DatetimeCreated;
var hs = sysUserService.Update(model);
var message = HandleError.GetMessage(hs, Crud.Update);
ResultHandle result = new ResultHandle {
Status = hs.Success, Message = stringLocalizer[message].Value
};
if (!hs.Success)
{
return(BadRequest(result));
}
return(Ok(result));
}
else
{
return(BadRequest(resultEmployee));
}
}
/// <summary>
/// Register the error handler for response errror.
/// </summary>
/// <param name="handleError"></param>
public void OnResponseError(HandleError handleError)
{
Ensure.NotNull(handleError, "handleError");
_responseErrorHandler = ErrorHandler.Default(handleError).WithFallback(_genericErrorHandler);
}
/// <summary>
/// Register the error handler for polling error.
/// </summary>
/// <param name="handleError"></param>
public void OnPollingError(HandleError handleError)
{
Ensure.NotNull(handleError, "handleError");
_pollingErrorHandler = ErrorHandler.Default(handleError).WithFallback(_genericErrorHandler);
}
private async void GetData()
{
Globals.StatusBar.ProgressPercentage = 0;
Globals.StatusBar.IsWorkProcessing = true;
Globals.StatusBar.ProgressText = "Retrieving Data";
try
{
using (Vndb client = new Vndb(true))
{
bool hasMore = true;
RequestOptions ro = new RequestOptions {
Count = 25
};
int pageCount = 1;
int characterCount = 0;
int releasesCount = 0;
List <Character> characterList = new List <Character>();
while (hasMore)
{
ro.Page = pageCount;
VndbResponse <Character> characters = await client.GetCharacterAsync(VndbFilters.VisualNovel.Equals(_vnid), VndbFlags.FullCharacter, ro);
if (characters != null)
{
hasMore = characters.HasMore;
characterList.AddRange(characters.Items);
characterCount = characterCount + characters.Count;
pageCount++;
}
if (characters != null)
{
continue;
}
HandleError.HandleErrors(client.GetLastError(), 0);
return;
}
hasMore = true;
pageCount = 1;
//do progress here
VndbResponse <VisualNovel> visualNovels = await client.GetVisualNovelAsync(VndbFilters.Id.Equals(_vnid), VndbFlags.FullVisualNovel);
if (visualNovels == null)
{
HandleError.HandleErrors(client.GetLastError(), 0);
return;
}
List <Release> releaseList = new List <Release>();
while (hasMore)
{
ro.Page = pageCount;
VndbResponse <Release> releases = await client.GetReleaseAsync(VndbFilters.VisualNovel.Equals(_vnid), VndbFlags.FullRelease, ro);
if (releases == null)
{
HandleError.HandleErrors(client.GetLastError(), 0);
break;
}
hasMore = releases.HasMore;
releaseList.AddRange(releases.Items);
releasesCount = releasesCount + releases.Count;
pageCount++;
}
_progressIncrement = (double)100 / (1 + characterCount);
//await save vn data here
Globals.StatusBar.ProgressText = "Processing Data";
Globals.StatusBar.IsDbProcessing = true;
await AddToDatabase(visualNovels, releaseList, characterList);
}
}
catch (Exception ex)
{
Globals.Logger.Error(ex);
throw;
}
}
