public void Execute(GenericResult genericResult, ControllerContext controllerContext)
{
if (genericResult.Refresh)
{
new RedirectResult(controllerContext.HttpContext.Request.RawUrl).ExecuteResult(controllerContext);
return;
}
if (genericResult.RedirectUri != null)
{
new RedirectResult(genericResult.RedirectUri.ToString()).ExecuteResult(controllerContext);
return;
}
var viewName = genericResult.ResultName ?? (string)controllerContext.RouteData.Values["action"];
ViewEngineResult view = ViewEngines.Engines.FindView(controllerContext, viewName, null);
if (view.View == null)
return;
var viewResult = new ViewResult();
controllerContext.Controller.ViewData.Model = genericResult.Model;
viewResult.ViewName = viewName;
viewResult.ViewData = controllerContext.Controller.ViewData;
viewResult.TempData = controllerContext.Controller.TempData;
foreach (var message in genericResult.Messages.Where(m => m.Category == MessageCategory.Error))
controllerContext.Controller.ViewData.ModelState.AddModelError(message.Field ?? message.Text, message.Text);
viewResult.ExecuteResult(controllerContext);
}
public void Execute(GenericResult genericResult, ControllerContext controllerContext)
{
var request = controllerContext.HttpContext.Request;
var response = controllerContext.HttpContext.Response;
if (request.Headers["X-Correlation-Id"] != null)
response.Headers.Add("X-Correlation-Id", request.Headers["X-Correlation-Id"]);
response.ContentType = MimeType.JSON;
response.Write(JsonConvert.SerializeObject(genericResult.ToDictionary(), Formatting.None, JSONSettings));
}
public GenericResult <List <pedido> > Pedidos(string token, string status, int offset)
{
var result = new GenericResult <List <pedido> >();
var url = string.Format("{0}{1}/{2}/{3}", _urlBase, Constants.URL_PEDIDOS, status, offset);
var client = new RestClient(url);
var request = new RestRequest(Method.GET);
request.AddHeader("Accept", "application/json");
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Auth-Token", token);
IRestResponse response = client.Execute(request);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
result.Result = JsonConvert.DeserializeObject <List <pedido> >(response.Content);
result.Success = true;
result.Json = response.Content;
}
else if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
{
result.Result = new List <pedido>();
result.Success = true;
}
else
{
if (!string.IsNullOrEmpty(response.Content))
{
if (response.Content.Contains("Nenhum registro foi encontrado."))
{
result.Result = new List <pedido>();
result.Success = true;
}
else
{
result.Message = response.Content + " " + response.ErrorMessage + " " + response.StatusDescription;
}
}
else
{
result.Message = (int)response.StatusCode + " " + response.ErrorMessage + " " + response.StatusDescription;
}
}
return(result);
}
public IActionResult Delete(
int id,
[FromServices] NaturezaService service,
[FromServices] IMemoryCache cache
)
{
NaturezaDeleteCommand command = new NaturezaDeleteCommand(id);
GenericResult result = service.Exec(command);
if (result.Status == 204)
{
cache.Remove(id);
}
return(StatusCode(result.Status, result));
}
public IActionResult Post([FromBody] User user)
{
IActionResult result = new ObjectResult(false);
GenericResult editResult = null;
var authenticationHeader = Request?.Headers["Authorization"];
var token = authenticationHeader?.FirstOrDefault().Split(' ')[1];
var jwt = new JwtSecurityToken(token);
var subject = jwt.Subject;
var dbUser = _userRepository.GetSingleByUsername(subject);
user.HashedPassword = dbUser.HashedPassword;
user.Salt = dbUser.Salt;
if (user.Photo == "images/" || user.Photo == "")
{
user.Photo = dbUser.Photo;
}
try
{
_userRepository.Edit(user);
_userRepository.Commit();
editResult = new GenericResult()
{
Succeeded = true,
Message = "User updated."
};
}
catch (Exception ex)
{
editResult = new GenericResult()
{
Succeeded = false,
Message = ex.Message + user.Photo
};
_loggingRepository.Add(new Error()
{
Message = ex.Message,
StackTrace = ex.StackTrace,
DateCreated = DateTime.Now
});
_loggingRepository.Commit();
}
result = new ObjectResult(editResult);
return(result);
}
public async Task <ObjectResult> ConnectionDirect()
{
GenericResult gr = new GenericResult();
try
{
string stringGMSDBConnection =
"Server=27.0.12.24;Database=gGMS;User Id=gGMS;Password=gGMS@239;MultipleActiveResultSets=True;";
var conn = new SqlConnection(stringGMSDBConnection);
List <string> list = new List <string>();
if (conn.State == ConnectionState.Closed)
{
conn.Open();
}
var cmd = conn.CreateCommand();
cmd.CommandText = "exec PRD_CATEGORY_MASTER_Lst";
var reader = cmd.ExecuteReader();
while (reader.Read())
{
var name = reader["CATEGORY_NAME"].ToString();
list.Add(name);
}
gr.Data = list;
}
catch (Exception ex)
{
gr.Message = ex.Message;
gr.Data = ex;
gr.Succeeded = false;
}
ObjectResult obj = new ObjectResult(gr);
return(obj);
}
protected override async Task GetFileListByPath(string path)
{
IEnumerable <FileMetaData[]> GetFileList()
{
int currentPage = 0;
int totalPage;
do
{
GenericResult <FileListPage> x = fileSystem.GetDirectory(path: path, page: ++currentPage);
if (x.Success && x.Result.DictionaryInformation != null)
{
totalPage = x.Result.TotalPage;
CurrentPath = x.Result.DictionaryInformation.Path;
CurrentUUID = x.Result.DictionaryInformation.UUID;
CreatePathArray(CurrentPath);
yield return(x.Result.List);
}
else
{
throw new DirectoryNotFoundException(x.Message);
}
} while (currentPage < totalPage);
yield break;
}
App.Current.Dispatcher.Invoke(() => FileList.Clear());
await Task.Run(() =>
{
fileMetaDataEnumerator = GetFileList().GetEnumerator();
fileMetaDataEnumerator.MoveNext();
});
App.Current.Dispatcher.Invoke(() =>
{
foreach (FileMetaData a in fileMetaDataEnumerator.Current)
{
if (Mode == Mode.PathSelector && !a.Directory)
{
continue;
}
FileList.Add(new FileListItemViewModel(this, a));
}
});
}
public async Task <IActionResult> IndexAsync(int?groupId)
{
GenericResult result = null;
var group = await groupRepository.GetSingleByIdAsync(groupId);
if (group == null)
{
return(NotFound());
}
try
{
var groupRights = await groupRightsRepository
.AsQueryable()
.Where(gr => gr.Groupid == groupId)
.OrderBy(gr => gr.Key)
.ToListAsync();
var groupRightsVM = await GetMenuAsync(groupId, groupRights);
if (groupRightsVM == null)
{
return(NotFound());
}
result = new GenericResult
{
Succeeded = true,
CustomData = groupRightsVM
};
}
catch (Exception ex)
{
result = new GenericResult
{
Succeeded = false,
Message = ex.Message
};
Logger.Error(ex, ex.Message);
}
return(new ObjectResult(result));
}
public GenericResult RunNoteCalcCtlrCalcAndSave()
{
string Url = "http://*****:*****@"C:\Temp\9946.json");
if (_notedc == null)
{
_notedc = ReadJSONFile(lblFile.Text);
}
WriteText(_notedc.SaveWithoutCalc);
_notedc.SaveWithoutCalc = "N";
if (_notedc != null)
{
string apiPath = "api/note/CalculateNoteAndSaveByNoteID";
//string serializeJSON = JsonConvert.SerializeObject(json);
using (var client = new HttpClient())
{
//var res = client.PostAsync(Url + apiPath, new StringContent(serializeJSON, Encoding.UTF8, "application/json"));
var res = client.PostAsJsonAsync(Url + apiPath, _notedc);
try
{
HttpResponseMessage response1 = res.Result.EnsureSuccessStatusCode();
if (response1.IsSuccessStatusCode)
{
// Add code
WriteText("Completed Successfully!");
}
}
catch (System.Exception e)
{
_Result = new GenericResult()
{
Succeeded = false,
Message = e.StackTrace
};
System.Console.WriteLine(e.ToString());
}
}
}
return(_Result);
}
private void btnThem_Click(object sender, EventArgs e)
{
btnThem.Text = btnThem.Text.Equals("Thêm nhà cung cấp") ? "Lưu" : "Thêm nhà cung cấp";
if (btnThem.Text.Equals("Thêm nhà cung cấp")) // An nut them lan 2
{
if (!isValid())
{
MessageBox.Show("Bạn phải nhập đầy đủ thông tin !!!");
btnThem.Text = "Lưu";
return;
}
//Code
GenericResult rs = _supplierService.Add(new SupplierViewModel()
{
FullName = txtTen.Text.Trim(),
Address = txtDiaChi.Text.Trim(),
DateCreated = DateTime.Now,
PhoneNumber = txtSoDT.Text.Trim(),
Status = chkTrangThai.Checked == true ? Status.Active : Status.InActive
});
_supplierService.Save();
if (rs.Success)
{
FormHelper.showSuccessDialog(rs.Message, rs.Caption);
}
else
{
FormHelper.showErrorDialog(rs.Message, rs.Error, rs.Caption);
}
//End Code
loadGvNhaCungCap();
update_Edit();
gv_NhaCC.Enabled = true;
setBtnBack_False();
setEdit_False();
}
else //Vua nhan nut them
{
setEdit_True();
saveStament();
setBtnBack_True();
reStart();
gv_NhaCC.Enabled = false;
}
}
public GenericResult <string> GetSetting(string key)
{
var result = new GenericResult <string>();
try
{
using (var db = new RssAggregatorModelContainer())
{
result.SetDataResult(db.GetEntity <Settings>(el => el.Key == key).Value);
}
}
catch (Exception ex)
{
Logger.LogException(ex, LogTypeEnum.BAL);
}
return(result);
}
public async Task <GenericResult <LoginResponseModel> > AuthenticateWithUserNamePassword(LoginRequestModel model)
{
try
{
var usr = _dwhContext.Users.ToList();
if (model == null)
{
return(GenericResult <LoginResponseModel> .Fail("Request is invalid."));
}
throw new NotImplementedException();
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
private static void GetToolEngineers(IProvider provider, IResource res, GenericResult result)
{
object data = null;
if (Validate(res, result))
{
IList <IResourceClient> toolEng = ResourceClients.GetToolEngineers(res.ResourceID).ToList();
int[] existingToolEngClientIDs = toolEng.Select(x => AsAuthorized(x).ClientID).ToArray();
IList <IClient> staff = provider.Data.Client.FindByPrivilege(ClientPrivilege.Staff, true).Where(x => !existingToolEngClientIDs.Contains(x.ClientID)).ToList();
data = new
{
ToolEngineers = toolEng.Select(x => new { AsAuthorized(x).ClientID, x.DisplayName }).OrderBy(x => x.DisplayName),
Staff = staff.Select(x => new { x.ClientID, x.DisplayName }).OrderBy(x => x.DisplayName)
};
result.Data = data;
}
}
public async Task <IActionResult> IsAdminLogged()
{
ApplicationUser user = await _userManager.GetUserAsync(HttpContext.User);
var gr = new GenericResult
{
Succeeded = true,
IsAdminLogged = false
};
// Embedded since this is a demo after all.
if (user != null && user.UserName == _adminUserName)
{
gr.IsAdminLogged = true;
}
return(Ok(gr));
}
public async Task <RuntimeResult> AddSkillAsync(string name, Special special)
{
if (_statService.NameExists(name))
{
return(StatisticResult.StatisticAlreadyExists());
}
var newSkill = new Skill
{
Name = name,
Special = special,
Aliases = name + "/"
};
await _statService.AddStatisticAsync(newSkill);
return(GenericResult.FromSuccess(Messages.SKILLS_ADDED));
}
public GenericResult <IDictionary <string, string> > GetAllUISettings()
{
var result = new GenericResult <IDictionary <string, string> >();
try
{
using (var db = new RssAggregatorModelContainer())
{
result.SetDataResult(db.GetDBSet <Settings>(el => el.ForUI).ToDictionary(el => el.Key, el => el.Value));
}
}
catch (Exception ex)
{
Logger.LogException(ex, LogTypeEnum.BAL);
}
return(result);
}
public IActionResult GetAlbumsId()
{
var result = _context.Albums.OrderBy(a => a.Id);
List <int> ids = new List <int>();
foreach (var album in result)
{
ids.Add(album.Id);
}
var gr = new GenericResult
{
Succeeded = true,
AlbumsId = JsonConvert.SerializeObject(ids)
};
return(Ok(gr));
}
public GenericResult <Employee> GetEmployeeByIdWithoutSkills(int id)
{
var result = new GenericResult <Employee>();
try
{
result.Data = _workforceDbContext.Employees.Where(e => e.Id == id && !e.IsDeleted)
.Include(e => e.EmployeeSkillset)
.AsNoTracking().FirstOrDefault();
result.Success = true;
}
catch (Exception ex)
{
result.Message = ex.Message;
}
return(result);
}
public async Task <RuntimeResult> RollManualAsync(Statistic stat, int value)
{
if (value > 5000)
{
return(GenericResult.FromError("Too high."));
}
var mockCharacter = new Character {
Name = Context.User.Username
};
mockCharacter.Statistics = new List <StatisticValue> {
new StatisticValue {
Statistic = stat, Value = value
}
};
return(await Task.FromResult(_rollService.RollStatistic(mockCharacter, stat)));
}
public async Task <GenericResult> ValidateAsync(object manager, TModule module)
{
var theManager = this.GetManager <TModule, IModuleManager <TModule, TProject> >(manager);
var errors = new List <GenericError>();
await this.ValidateNameAsync(theManager, Accessor, module, errors,
name => ErrorDescriber.InvalidModuleName(name), name => ErrorDescriber.DuplicateModuleName(name));
var internalMethod = GetType().GetMethod("ValidateInternalAsync",
System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
if (internalMethod != null)
{
internalMethod.Invoke(this, new object[] { manager, module, errors });
}
return(GenericResult.GetResult(errors));
}
public async Task <RuntimeResult> SpendSkillPointsAsync(Skill skill, int points)
{
if (!ExperienceService.UseOldProgression)
{
return(StatisticResult.NotUsingOldProgression());
}
var userInfo = Context.User;
var character = await _charService.GetCharacterAsync(userInfo.Id);
if (character == null)
{
return(CharacterResult.CharacterNotFound());
}
if (!_skillsService.AreSkillsSet(character))
{
return(StatisticResult.SkillsNotSet());
}
if (points < 1)
{
return(GenericResult.FromError(Messages.ERR_SKILLS_POINTS_BELOW_ONE));
}
if (points > character.ExperiencePoints)
{
return(GenericResult.FromError(Exceptions.CHAR_NOT_ENOUGH_SKILL_POINTS));
}
var skillVal = _statsService.GetStatistic(character, skill);
if ((skillVal + points) > _roleplayOptions.SkillMax)
{
return(GenericResult.FromError(Exceptions.CHAR_SKILL_POINTS_GOES_OVER_MAX));
}
_statsService.SetStatistic(character, skill, skillVal + points);
character.ExperiencePoints -= points;
await _charService.SaveCharacterAsync(character);
return(GenericResult.FromSuccess(Messages.SKILLS_SPEND_POINTS_SUCCESS));
}
protected void DeserializeGeneric(ServiceResponse xmlStream, GenericResult result)
{
result.HttpStatusCode = xmlStream.StatusCode;
if (xmlStream.Headers.ContainsKey(HttpHeaders.RequestId))
{
result.RequestId = xmlStream.Headers[HttpHeaders.RequestId];
}
if (xmlStream.Headers.ContainsKey(HttpHeaders.ContentLength))
{
result.ContentLength = long.Parse(xmlStream.Headers[HttpHeaders.ContentLength]);
}
if (xmlStream.Headers.ContainsKey(HttpHeaders.ServerElapsedTime))
{
result.ResponseMetadata.Add(HttpHeaders.ServerElapsedTime, xmlStream.Headers[HttpHeaders.ServerElapsedTime]);
}
if (xmlStream.Headers.ContainsKey(HttpHeaders.Date))
{
result.ResponseMetadata.Add(HttpHeaders.Date, xmlStream.Headers[HttpHeaders.Date]);
}
if (xmlStream.Headers.ContainsKey(HttpHeaders.ETag))
{
result.ResponseMetadata.Add(HttpHeaders.ETag, OssUtils.TrimQuotes(xmlStream.Headers[HttpHeaders.ETag]));
}
if (xmlStream.Headers.ContainsKey(HttpHeaders.ContentType))
{
result.ResponseMetadata.Add(HttpHeaders.ContentType, xmlStream.Headers[HttpHeaders.ContentType]);
}
if (xmlStream.Headers.ContainsKey(HttpHeaders.HashCrc64Ecma))
{
result.ResponseMetadata.Add(HttpHeaders.HashCrc64Ecma, xmlStream.Headers[HttpHeaders.HashCrc64Ecma]);
}
if (xmlStream.Headers.ContainsKey(HttpHeaders.ContentMd5))
{
result.ResponseMetadata.Add(HttpHeaders.ContentMd5, xmlStream.Headers[HttpHeaders.ContentMd5]);
}
}
public GenericResult <token> OathToken(string client_id, string client_secret)
{
var result = new GenericResult <token>();
try
{
var data = new
{
grant_type = "client_credentials",
client_id = client_id,
client_secret = client_secret
};
var url = _urlBase + Constants.URL_OAUTH;
var client = new RestClient(url);
client.Timeout = -1;
var request = new RestRequest(Method.POST);
request.AddHeader("Accept", "application/json");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", JsonConvert.SerializeObject(data), ParameterType.RequestBody);
IRestResponse responseToken = client.Execute(request);
if (responseToken.StatusCode == System.Net.HttpStatusCode.OK)
{
result.Result = JsonConvert.DeserializeObject <token>(responseToken.Content);
result.Success = true;
}
else
{
var error = JsonConvert.DeserializeObject <erro>(responseToken.Content);
result.Message = responseToken.StatusDescription + $" {error.error} => {error.message}";
}
result.StatusCode = responseToken.StatusCode;
}
catch (Exception ex)
{
result.Message = ex.Message;
}
return(result);
}
public async Task <IActionResult> LoginAsync([FromBody] LoginViewModel loginData)
{
GenericResult result = null;
try
{
var success = await membershipService.LoginAsync(HttpContext, loginData.Sid, loginData.Userid, loginData.Password);
if (!success)
{
result = new GenericResult
{
Succeeded = false,
Message = Localizer["Invalid User ID or Password"]
};
}
else
{
var session = await membershipService.GetSessionAsync(HttpContext, loginData.Sid);
var str = Newtonsoft.Json.JsonConvert.SerializeObject(session, new Newtonsoft.Json.JsonSerializerSettings {
ContractResolver = new LowercaseContractResolver()
});
var dict = Newtonsoft.Json.JsonConvert.DeserializeObject(str);
result = new GenericResult
{
Succeeded = true,
CustomData = dict
};
}
}
catch (Exception ex)
{
result = new GenericResult
{
Succeeded = false,
Message = ex.Message
};
Logger.Error(ex, ex.Message);
}
return(new ObjectResult(result));
}
//[Authorize(Roles = "EditMenuRole")]
public IActionResult Put([FromBody] MenuRoleViewModel menuRoleViewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
IActionResult result = new ObjectResult(false);
GenericResult updateResult = null;
try
{
if (menuRoleViewModel.MenuLink == "/")
{
menuRoleViewModel.MenuLink = "";
}
var menuRole = _menuRoleService.GetById(menuRoleViewModel.MenuId);
menuRole.UpdateMenuRole(menuRoleViewModel);
// MenuRole menuRole = Mapper.Map<MenuRoleViewModel, MenuRole>(menuRoleViewModel);
_menuRoleService.Update(menuRole);
_menuRoleService.Save();
updateResult = new GenericResult()
{
Succeeded = true,
Message = "Cập nhật menu thành công"
};
}
catch (Exception ex)
{
updateResult = new GenericResult()
{
Succeeded = false,
Message = "Cập nhật menu thất bại"
};
_loggingRepository.Add(new Error()
{
Message = ex.Message, StackTrace = ex.StackTrace, DateCreated = DateTime.Now
});
_loggingRepository.Commit();
}
result = new ObjectResult(updateResult);
return(result);
}
[HttpPost("addUserToChat")]//now work
public async Task <IActionResult> AddUserToChat(int chatId, int userId)
{
IActionResult result = new ObjectResult(false);
GenericResult addingResult = null;
var authenticationHeader = Request?.Headers["Authorization"];
var token = authenticationHeader?.FirstOrDefault().Split(' ')[1];
var subject = _jwtFormater.GetSubject(token);
var user = _userRepository.GetSingleByUsername(subject);
try
{
var userChats = await _chatUserRepository.FindByAsync(cu => cu.UserId == user.Id);
var chatIds = userChats.Select(c => c.ChatId);
if (chatIds.Contains(chatId))
{
var cu = new ChatUser()
{
ChatId = chatId,
UserId = userId
};
_chatUserRepository.Add(cu);
_chatUserRepository.Commit();
}
addingResult = new GenericResult()
{
Succeeded = true,
Message = "Success!!!"
};
}
catch (Exception e)
{
addingResult = new GenericResult()
{
Succeeded = false,
Message = e.Message
};
}
result = new ObjectResult(addingResult);
return(result);
}
public async Task <ObjectResult> Post([FromBody] BotScenarioViewModel botScenarioViewModel)
{
GenericResult rs = new GenericResult();
try
{
botScenarioViewModel.BotScenario.RECORD_STATUS = 1;
this._context.BotScenarios.Add(botScenarioViewModel.BotScenario);
this._context.SaveChanges();
int countQuestion = botScenarioViewModel.BotQuestions.Count;
for (int i = 0; i < countQuestion; i++)
{
botScenarioViewModel.BotQuestions[i].SCENARIO_ID = botScenarioViewModel.BotScenario.SCENARIO_ID;
botScenarioViewModel.BotQuestions[i].LEVEL = 1;
botScenarioViewModel.BotQuestions[i].IS_END = false;
botScenarioViewModel.BotQuestions[i].RECORD_STATUS = 1;
this._context.BotQuestions.Add(botScenarioViewModel.BotQuestions[i]);
this._context.SaveChanges();
//if (botScenarioViewModel.BotQuestions[i].QUESTION_TYPE != 1)
//{
botScenarioViewModel.BotAnswers[i].QUESTION_ID = botScenarioViewModel.BotQuestions[i].QUESTION_ID;
botScenarioViewModel.BotAnswers[i].LEVEL = 1;
botScenarioViewModel.BotAnswers[i].IS_END = true;
botScenarioViewModel.BotAnswers[i].RECORD_STATUS = 1;
this._context.BotAnswers.Add(botScenarioViewModel.BotAnswers[i]);
this._context.SaveChanges();
//}
}
rs.Succeeded = true;
rs.Message = "Thêm kịch bản chat thành công";
ObjectResult objRes = new ObjectResult(rs);
//context.Dispose();
return(objRes);
}
catch (Exception ex)
{
rs.Message = "Lỗi " + ex.Message;
rs.Succeeded = false;
ObjectResult objRes = new ObjectResult(rs);
//context.Dispose();
return(objRes);
}
}
public async Task SetStatisticAsync_AboveMaximum_ReturnTooHigh()
{
// Arrange
var charProvider = new MockCharacterProvider();
var statProvider = new MockStatisticProvider();
var statOptions = new StatisticOptions
{
InitialAttributeMax = 10,
InitialAttributePoints = 12,
};
var controller = new StatisticController(charProvider, statProvider, new GenericProgressionStrategy(statProvider, statOptions));
// Act
var result = await controller.SetStatisticAsync(1, "strength", 11);
// Assert
Assert.Equal(GenericResult.ValueTooHigh(), result);
}
public GenericResult <result> Accept(string token, string id)
{
var result = new GenericResult <result>();
try
{
var url = string.Format("{0}{1}{2}", _urlBase, Constants.ORDER_ACCEPT, id);
var client = new RestClient(url);
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", token);
request.AddHeader("Accept", "application/json");
IRestResponse response = client.Execute(request);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
var _result = JsonConvert.DeserializeObject <result>(response.Content);
if (_result.success)
{
result.Success = true;
result.Json = response.Content;
}
else
{
result.Message = _result.message;
}
}
else
{
if (response.StatusDescription.Equals("Not Found"))
{
result.Message = "Não encontrado!";
}
else
{
result.Message = response.Content + " - " + response.StatusDescription;
}
}
}
catch (Exception ex)
{
result.Message = ex.Message;
}
return(result);
}
/// <summary>
/// Gets the caller's specified character by name, sets its story, and updates it.
/// </summary>
/// <param name="callerId">Discord ID of the caller.</param>
/// <param name="story">The new story of the character.</param>
/// <returns>A new CharacterResult object.</returns>
public async Task <IResult> SetCharacterStoryAsync(ulong callerId, string story)
{
if (string.IsNullOrEmpty(story))
{
return(GenericResult.InvalidInput());
}
var character = await _provider.GetActiveCharacterAsync(callerId);
if (character == null)
{
return(CharacterResult.CharacterNotFound());
}
character.Story = story;
await _provider.UpdateCharacterAsync(character);
return(CharacterResult.CharacterUpdatedSuccessfully());
}
public async Task <GenericResult <SignInPolicy> > GetSignInPolicy()
{
var result = new GenericResult <SignInPolicy>();
try
{
result.Data = await _policyAccessor.GetSignInPolicy();
result.Message = "Success";
}
catch (Exception ex)
{
result.IsFailure = true;
result.Exception = ex;
result.Message = ex.Message;
}
return(result);
}
public async Task <GenericResult <notificationModels.Notification, string> > Create(CreateNotificationRequest createNotificationRequest)
{
if (createNotificationRequest == null)
{
throw new ArgumentNullException("createNotificationRequest");
}
var result = new GenericResult <notificationModels.Notification, string>();
var notification = GetNotificationFromCreateNotificationRequest(createNotificationRequest);
await _notificationRepository.Create(notification);
// TODO: Generate a notification event, so the EventsService can deliver the notification to the user.
_eventsLogic.CreateClientEvent(GetPublishEventRequestFromNotification(MapNotification(notification), createNotificationRequest.UserId));
result.SuccessResult = notification;
return(result);
}
public GenericResult RestartSpoolService()
{
GenericResult retVal = new GenericResult("RestartSpoolService");
try
{
ServiceController sc = new ServiceController("Spooler");
if (sc.Status != ServiceControllerStatus.Stopped || sc.Status != ServiceControllerStatus.StopPending)
sc.Stop();
sc.WaitForStatus(ServiceControllerStatus.Stopped);
sc.Start();
retVal.Success = true;
}
catch (Exception ex)
{
retVal.Exception = ex;
retVal.Message = retVal.Exception.Message;
}
return retVal;
}
public ChannelListMessage(GenericResult result)
: this()
{
this.Result = result;
}
public override void ReadPayload(ISerializationContext context, IValueReader reader)
{
this.Result = (GenericResult)reader.ReadByte();
if (this.Result != GenericResult.Success)
return;
DefaultChannelId = reader.ReadInt32();
int nchannels = reader.ReadInt32();
this.channels = new List<ChannelInfo> (nchannels);
for (int i = 0; i < nchannels; ++i)
this.channels.Add (new ChannelInfo (context, reader));
}
public static void WriteGenericResult(this IValueWriter writer, GenericResult result)
{
writer.WriteByte ((byte)result);
}
public GenericResult GetPrinterDirectory()
{
GenericResult retVal = new GenericResult("GetPrinterDirectory");
StringBuilder str = new StringBuilder(1024);
int i = 0;
GetPrinterDriverDirectory(null, null, 1, str, 1024, ref i);
try
{
GetPrinterDriverDirectory(null, null, 1, str, 1024, ref i);
retVal.Success = true;
retVal.Message = str.ToString();
}
catch (Exception ex)
{
retVal.Exception = ex;
retVal.Message = retVal.Exception.Message;
}
return retVal;
}
public static GenericResult AddContract(int resellerId, ContractAccount accountSettings)
{
try
{
ES.SecurityContext.SetThreadPrincipal(resellerId);
//
ES.TaskManager.StartTask(SystemTasks.SOURCE_ECOMMERCE, SystemTasks.TASK_ADD_CONTRACT);
//
GenericResult result = new GenericResult();
//
int customerId = -1;
int contractStatus = (int)ContractStatus.Pending;
//
if (accountSettings.PropertyExists(ContractAccount.CUSTOMER_ID))
{
customerId = accountSettings.GetProperty<int>(ContractAccount.CUSTOMER_ID);
//
contractStatus = (int)ContractStatus.Active;
}
// Ensure customer not specified and then check requested username availability
if (customerId == -1)
{
if (ES.UserController.UserExists(accountSettings[ContractAccount.USERNAME]))
{
result.Succeed = false;
result.SetProperty("ResultCode", ES.BusinessErrorCodes.ERROR_USER_ALREADY_EXISTS);
return result;
}
// EXIT
}
//
string strNames = null;
string strValues = null;
//
if (customerId == -1)
{
strNames = strValues = String.Empty;
SecurityUtils.SerializeGenericProfile(ref strNames, ref strValues, accountSettings);
}
// emit the new contract
string contractId = EcommerceProvider.AddContract(customerId, resellerId, accountSettings[ContractAccount.USERNAME],
contractStatus, 0m, accountSettings[ContractAccount.FIRST_NAME], accountSettings[ContractAccount.LAST_NAME],
accountSettings[ContractAccount.EMAIL], accountSettings[ContractAccount.COMPANY_NAME],
strNames, strValues);
//
result.Succeed = true;
result.SetProperty("ContractId", contractId);
// Add contract object
ES.TaskManager.TaskParameters[SystemTaskParams.PARAM_CONTRACT] = GetContract(contractId);
//
return result;
}
catch (Exception ex)
{
throw ES.TaskManager.WriteError(ex);
}
finally
{
ES.TaskManager.CompleteTask();
}
}
