private void onInitShipSuccess(BaseWWWRequest obj)
{
try
{
if (this.needZip)
{
this.initResponse = JsonReader.Deserialize<BasicResponse>(base.UTF8String);
}
else
{
this.initResponse = JsonReader.Deserialize<BasicResponse>(base.www.text);
}
if (this.initResponse.eid != 0)
{
this.onInitFail(obj);
}
else
{
ServerRequestManager.instance.OnChooseInitShipSuccess();
Debug.Log("onInitShipSuccess Success: " + base.www.text);
}
}
catch (Exception)
{
this.onInitFail(obj);
}
}
public BasicResponse AddCategory(CategoryDTO dto)
{
BasicResponse response = new BasicResponse();
try
{
var account = new Category()
{
Name = dto.Name,
Id = dto.Id,
AccountId = dto.AccountId,
Description = dto.Description,
IsActive = true,
CreatedOn = DateTime.Now,
UpdatedOn = DateTime.Now,
};
_categoryRepository.Save(account);
response.Status = true;
response.Info = "Success";
}
catch (Exception ex)
{
response.Status = false;
response.Info = ex.Message;
}
return response;
}
public BasicResponse Save(ClientDTO dto)
{
var response = new BasicResponse();
try
{
var entity = new Client
{
Code = dto.Code,
Id = dto.Id,
Name = dto.Name,
IsActive = true,
};
_clientRepository.Save(entity);
response.Status = true;
response.Info = "Success";
}
catch (Exception ex)
{
response.Status = false;
if (ex is DomainValidationException)
{
var dex = ex as DomainValidationException;
response.Info = dex.FormatException();
}
else
{
response.Status = false;
response.Info = ex.Message;
}
}
return response;
}
public BasicResponse <List <GasContentAlarmInfo> > GetAllGasContentAlarmCache()
{
var res = _gasContentAlarmCacheService.GetAllCache();
var ret = new BasicResponse <List <GasContentAlarmInfo> >
{
Data = res.Data
};
return(ret);
}
public BasicResponse <List <GascontentanalyzeconfigInfo> > GetAllCache()
{
var info = GasContentAnalyzeConfigCache.CacheInstance.Query();
var ret = new BasicResponse <List <GascontentanalyzeconfigInfo> >
{
Data = info
};
return(ret);
}
public BasicResponse <RoledatarightInfo> UpdateRoledataright(RoledatarightUpdateRequest roledatarightrequest)
{
var _roledataright = ObjectConverter.Copy <RoledatarightInfo, RoledatarightModel>(roledatarightrequest.RoledatarightInfo);
_Repository.UpdateRoledataright(_roledataright);
var roledatarightresponse = new BasicResponse <RoledatarightInfo>();
roledatarightresponse.Data = ObjectConverter.Copy <RoledatarightModel, RoledatarightInfo>(_roledataright);
return(roledatarightresponse);
}
public BasicResponse <DataexchangesettingInfo> UpdateDataexchangesetting(DataexchangesettingUpdateRequest dataexchangesettingrequest)
{
var _dataexchangesetting = ObjectConverter.Copy <DataexchangesettingInfo, DataexchangesettingModel>(dataexchangesettingrequest.DataexchangesettingInfo);
_Repository.UpdateDataexchangesetting(_dataexchangesetting);
var dataexchangesettingresponse = new BasicResponse <DataexchangesettingInfo>();
dataexchangesettingresponse.Data = ObjectConverter.Copy <DataexchangesettingModel, DataexchangesettingInfo>(_dataexchangesetting);
return(dataexchangesettingresponse);
}
public BasicResponse <AreaRuleInfo> UpdateAreaRule(AreaRuleUpdateRequest areaRuleRequest)
{
var _areaRule = ObjectConverter.Copy <AreaRuleInfo, AreaRuleModel>(areaRuleRequest.AreaRuleInfo);
_Repository.UpdateAreaRule(_areaRule);
var areaRuleresponse = new BasicResponse <AreaRuleInfo>();
areaRuleresponse.Data = ObjectConverter.Copy <AreaRuleModel, AreaRuleInfo>(_areaRule);
return(areaRuleresponse);
}
/// <summary>
/// 批量删除
/// </summary>
/// <param name="jC_Analysistemplaterequest">模型ID</param>
/// <returns></returns>
public BasicResponse DeleteJC_AnalyticalexpressionByTempleteId(AnalyticalExpressionGetListRequest jC_Analysistemplaterequest)
{
var getAnalysisTemplateListByTempleteIdData = GetAnalysisTemplateListByTempleteId(jC_Analysistemplaterequest).Data;
var _jC_Analyticalexpression = ObjectConverter.CopyList <JC_AnalyticalExpressionInfo, JC_AnalyticalexpressionModel>(getAnalysisTemplateListByTempleteIdData);
_Repository.Delete(_jC_Analyticalexpression.ToList());
var jC_Analyticalexpressionresponse = new BasicResponse();
return(jC_Analyticalexpressionresponse);
}
/// <summary>
/// 批量新增表达式
/// </summary>
/// <param name="jC_ExpressionconfigModelList"></param>
/// <returns></returns>
public BasicResponse <List <JC_AnalyticalExpressionInfo> > AddAnalyticalExpressionList(AnalyticalExpressionListAddRequest jC_AnalyticalExpressionrequest)
{
var _jC_AnalyticalExpression = ObjectConverter.CopyList <JC_AnalyticalExpressionInfo, JC_AnalyticalexpressionModel>(jC_AnalyticalExpressionrequest.JC_AnalyticalExpressionInfoList);
var resultjC_AnalyticalExpression = _Repository.AddAnalyticalexpressionList(_jC_AnalyticalExpression);
var jC_AnalyticalExpressionresponse = new BasicResponse <List <JC_AnalyticalExpressionInfo> >();
jC_AnalyticalExpressionresponse.Data = ObjectConverter.CopyList <JC_AnalyticalexpressionModel,
JC_AnalyticalExpressionInfo>(resultjC_AnalyticalExpression).ToList();
return(jC_AnalyticalExpressionresponse);
}
public BasicResponse <JC_MbInfo> UpdateMb(JC_MbUpdateRequest mbrequest)
{
var _mb = ObjectConverter.Copy <JC_MbInfo, JC_MbModel>(mbrequest.MbInfo);
_Repository.UpdateMb(_mb);
var mbresponse = new BasicResponse <JC_MbInfo>();
mbresponse.Data = ObjectConverter.Copy <JC_MbModel, JC_MbInfo>(_mb);
return(mbresponse);
}
public BasicResponse <List <AreaRuleInfo> > GetAreaRuleListByAreaID(GetAreaRuleListByAreaIDRequest areaRuleRequest)
{
var result = _Repository.GetAreaRuleList();
var areaRuleInfo = ObjectConverter.CopyList <AreaRuleModel, AreaRuleInfo>(result);
List <AreaRuleInfo> areaRuleItems = areaRuleInfo.Where(a => a.Areaid == areaRuleRequest.areaID).ToList();
var areaRuleresponse = new BasicResponse <List <AreaRuleInfo> >();
areaRuleresponse.Data = areaRuleItems;
return(areaRuleresponse);
}
internal BasicResponse(BasicResponse basicResponse)
{
if (basicResponse == null)
{
throw new ArgumentNullException(nameof(basicResponse));
}
FinalUri = basicResponse.FinalUri;
StatusCode = basicResponse.StatusCode;
}
public BasicResponse <ListtempleInfo> UpdateListtemple(ListtempleUpdateRequest listtemplerequest)
{
var _listtemple = ObjectConverter.Copy <ListtempleInfo, ListtempleModel>(listtemplerequest.ListtempleInfo);
_Repository.UpdateListtemple(_listtemple);
var listtempleresponse = new BasicResponse <ListtempleInfo>();
listtempleresponse.Data = ObjectConverter.Copy <ListtempleModel, ListtempleInfo>(_listtemple);
return(listtempleresponse);
}
public void OnMatchDestroyed(BasicResponse resp)
{
if (_disconnectServer)
{
StopMatchMaker();
StopHost();
}
mainMenuPanel.gameObject.SetActive(true);
topBar.gameObject.SetActive(true);
}
public async Task <BasicResponse <Member> > UpdateMember(Member member)
{
//need to add validations prior to update
var response = new BasicResponse <Member>();
await _memberRepository.Update(member);
response.Object = member;
response.WasSuccessful = true;
return(response);
}
public BasicResponse <Jc_BxexInfo> UpdateCalibrationStatistics(Jc_BxexUpdateRequest jc_Bxexrequest)
{
var _jc_Bxex = ObjectConverter.Copy <Jc_BxexInfo, Jc_BxexModel>(jc_Bxexrequest.Jc_BxexInfo);
_Repository.UpdateCalibrationStatistics(_jc_Bxex);
var jc_Bxexresponse = new BasicResponse <Jc_BxexInfo>();
jc_Bxexresponse.Data = ObjectConverter.Copy <Jc_BxexModel, Jc_BxexInfo>(_jc_Bxex);
return(jc_Bxexresponse);
}
public BasicResponse <Jc_ShowInfo> UpdateJc_Show(Jc_ShowUpdateRequest jc_Showrequest)
{
var _jc_Show = ObjectConverter.Copy <Jc_ShowInfo, Jc_ShowModel>(jc_Showrequest.Jc_ShowInfo);
_Repository.UpdateJc_Show(_jc_Show);
var jc_Showresponse = new BasicResponse <Jc_ShowInfo>();
jc_Showresponse.Data = ObjectConverter.Copy <Jc_ShowModel, Jc_ShowInfo>(_jc_Show);
return(jc_Showresponse);
}
public BasicResponse <JC_AnalyticalExpressionInfo> UpdateJC_Analyticalexpression(AnalyticalExpressionUpdateRequest jC_Analyticalexpressionrequest)
{
var _jC_Analyticalexpression = ObjectConverter.Copy <JC_AnalyticalExpressionInfo, JC_AnalyticalexpressionModel>(jC_Analyticalexpressionrequest.JC_AnalyticalExpressionInfo);
_Repository.UpdateJC_Analyticalexpression(_jC_Analyticalexpression);
var jC_Analyticalexpressionresponse = new BasicResponse <JC_AnalyticalExpressionInfo>();
jC_Analyticalexpressionresponse.Data = ObjectConverter.Copy <JC_AnalyticalexpressionModel, JC_AnalyticalExpressionInfo>(_jC_Analyticalexpression);
return(jC_Analyticalexpressionresponse);
}
public BasicResponse <JC_AlarmHandleInfo> UpdateJC_AlarmHandle(AlarmHandleUpdateRequest jC_AlarmHandlerequest)
{
var _jC_AlarmHandle = ObjectConverter.Copy <JC_AlarmHandleInfo, JC_AlarmHandleModel>(jC_AlarmHandlerequest.JC_AlarmHandleInfo);
_Repository.UpdateJC_AlarmHandle(_jC_AlarmHandle);
var jC_AlarmHandleresponse = new BasicResponse <JC_AlarmHandleInfo>();
jC_AlarmHandleresponse.Data = ObjectConverter.Copy <JC_AlarmHandleModel, JC_AlarmHandleInfo>(_jC_AlarmHandle);
return(jC_AlarmHandleresponse);
}
public BasicResponse <RolewebmenuInfo> UpdateRolewebmenu(RolewebmenuUpdateRequest rolewebmenurequest)
{
var _rolewebmenu = ObjectConverter.Copy <RolewebmenuInfo, RolewebmenuModel>(rolewebmenurequest.RolewebmenuInfo);
_Repository.UpdateRolewebmenu(_rolewebmenu);
var rolewebmenuresponse = new BasicResponse <RolewebmenuInfo>();
rolewebmenuresponse.Data = ObjectConverter.Copy <RolewebmenuModel, RolewebmenuInfo>(_rolewebmenu);
return(rolewebmenuresponse);
}
public BasicResponse <DataTable> QueryTableBySql(SqlRequest req)
{
var dt = _listexRepository.QueryTableBySql(req.Sql);
var ret = new BasicResponse <DataTable>()
{
Data = dt
};
return(ret);
}
public BasicResponse <Jc_RemarkInfo> UpdateJc_Remark(Jc_RemarkUpdateRequest jc_Remarkrequest)
{
var _jc_Remark = ObjectConverter.Copy <Jc_RemarkInfo, Jc_RemarkModel>(jc_Remarkrequest.Jc_RemarkInfo);
_Repository.UpdateJc_Remark(_jc_Remark);
var jc_Remarkresponse = new BasicResponse <Jc_RemarkInfo>();
jc_Remarkresponse.Data = ObjectConverter.Copy <Jc_RemarkModel, Jc_RemarkInfo>(_jc_Remark);
return(jc_Remarkresponse);
}
public BasicResponse <R_SyncLocalInfo> UpdateSyncLocal(R_SyncLocalUpdateRequest syncLocalRequest)
{
var _syncLocal = ObjectConverter.Copy <R_SyncLocalInfo, R_SyncLocalModel>(syncLocalRequest.SyncLocalInfo);
_Repository.UpdateSyncLocal(_syncLocal);
var syncLocalresponse = new BasicResponse <R_SyncLocalInfo>();
syncLocalresponse.Data = ObjectConverter.Copy <R_SyncLocalModel, R_SyncLocalInfo>(_syncLocal);
return(syncLocalresponse);
}
public BasicResponse <MetadataInfo> UpdateMetadata(MetadataUpdateRequest metadatarequest)
{
var _metadata = ObjectConverter.Copy <MetadataInfo, MetadataModel>(metadatarequest.MetadataInfo);
_Repository.UpdateMetadata(_metadata);
var metadataresponse = new BasicResponse <MetadataInfo>();
metadataresponse.Data = ObjectConverter.Copy <MetadataModel, MetadataInfo>(_metadata);
return(metadataresponse);
}
public BasicResponse <B_CallhistoryInfo> UpdateB_Callhistory(B_CallhistoryUpdateRequest b_CallhistoryRequest)
{
var _b_Callhistory = ObjectConverter.Copy <B_CallhistoryInfo, B_CallhistoryModel>(b_CallhistoryRequest.B_CallhistoryInfo);
_Repository.UpdateB_Callhistory(_b_Callhistory);
var b_Callhistoryresponse = new BasicResponse <B_CallhistoryInfo>();
b_Callhistoryresponse.Data = ObjectConverter.Copy <B_CallhistoryModel, B_CallhistoryInfo>(_b_Callhistory);
return(b_Callhistoryresponse);
}
public BasicResponse <List <GascontentanalyzeconfigInfo> > GetCacheByCondition(GasContentAnalyzeConfigGetCacheByConditionRequest request)
{
var infos = GasContentAnalyzeConfigCache.CacheInstance.Query().Where(request.Condition).ToList();
var ret = new BasicResponse <List <GascontentanalyzeconfigInfo> >
{
Data = infos
};
return(ret);
}
public BasicResponse <RunlogInfo> UpdateRunlog(RunlogUpdateRequest runlogrequest)
{
var _runlog = ObjectConverter.Copy <RunlogInfo, RunlogModel>(runlogrequest.RunlogInfo);
_Repository.UpdateRunlog(_runlog);
var runlogresponse = new BasicResponse <RunlogInfo>();
runlogresponse.Data = ObjectConverter.Copy <RunlogModel, RunlogInfo>(_runlog);
return(runlogresponse);
}
public BasicResponse <List <Member> > GetAllMembers()
{
var response = new BasicResponse <List <Member> >();
var members = _memberRepository.GetAll().ToList();
response.WasSuccessful = true;
response.Object = members;
return(response);
}
public BasicResponse <OperatelogInfo> UpdateOperatelog(OperatelogUpdateRequest operatelogrequest)
{
var _operatelog = ObjectConverter.Copy <OperatelogInfo, OperatelogModel>(operatelogrequest.OperatelogInfo);
_Repository.UpdateOperatelog(_operatelog);
var operatelogresponse = new BasicResponse <OperatelogInfo>();
operatelogresponse.Data = ObjectConverter.Copy <OperatelogModel, OperatelogInfo>(_operatelog);
return(operatelogresponse);
}
public BasicResponse <Member> GetMemberById(int memberId)
{
var response = new BasicResponse <Member>();
var member = _memberRepository.GetById(memberId);
response.WasSuccessful = true;
response.Object = member;
return(response);
}
public BasicResponse <PowerboxchargehistoryInfo> UpdatePowerboxchargehistory(PowerboxchargehistoryUpdateRequest powerboxchargehistoryRequest)
{
var _powerboxchargehistory = ObjectConverter.Copy <PowerboxchargehistoryInfo, PowerboxchargehistoryModel>(powerboxchargehistoryRequest.PowerboxchargehistoryInfo);
_Repository.UpdatePowerboxchargehistory(_powerboxchargehistory);
var powerboxchargehistoryresponse = new BasicResponse <PowerboxchargehistoryInfo>();
powerboxchargehistoryresponse.Data = ObjectConverter.Copy <PowerboxchargehistoryModel, PowerboxchargehistoryInfo>(_powerboxchargehistory);
return(powerboxchargehistoryresponse);
}
public BasicResponse <Jc_BzInfo> UpdateJc_Bz(Jc_BzUpdateRequest jc_Bzrequest)
{
var _jc_Bz = ObjectConverter.Copy <Jc_BzInfo, Jc_BzModel>(jc_Bzrequest.Jc_BzInfo);
_Repository.UpdateJc_Bz(_jc_Bz);
var jc_Bzresponse = new BasicResponse <Jc_BzInfo>();
jc_Bzresponse.Data = ObjectConverter.Copy <Jc_BzModel, Jc_BzInfo>(_jc_Bz);
return(jc_Bzresponse);
}
public BasicResponse <List <Member> > GetAllMembersByInstitution(int institutionId)
{
var response = new BasicResponse <List <Member> >();
var members = _memberRepository.GetAll().Where(x => x.InstitutionId == institutionId).ToList();
response.WasSuccessful = true;
response.Object = members;
return(response);
}
/// <summary>
/// Xử lý gen mã
/// </summary>
public BasicResponse GenCd(HttpContext context, BasicRequest request)
{
// Khai báo biến cục bộ
var response = new BasicResponse();
// Trường hợp là đăng ký
if (request.IsAdd) {
Thread.Sleep(1000);
response.Add("TypeCd", DataHelper.GetUniqueKey());
response.Add(BasicResponse.PROP_RESULT_FLAG, true);
}
// Kết quả xử lý
return response;
}
public void OnConnectionDrop(BasicResponse response)
{
if(response.success)
{
Debug.Log("CustomNetworkManager: connectecion droped succesful");
}
else
{
Debug.Log("CustomNetworkManager: connectecion droped failed (error: " + response.extendedInfo + ")");
}
StopClient();
}
public void CancelMatch(BasicResponse response)
{
if(response.success)
{
Debug.Log("CustomNetworkManager: match canceled succesful");
}
else
{
Debug.Log("CustomNetworkManager: match cancel failed (error: " + response.extendedInfo + ")");
}
StopHost();
}
private void onInitShipSuccess(BaseWWWRequest obj)
{
try
{
this.initResponse = new JsonReader().Read<BasicResponse>(base.UTF8String);
if (this.initResponse.eid != 0)
{
this.onInitFail(obj);
}
else
{
//ServerRequestManager.instance.OnChooseInitShipSuccess();
z.log("onInitShipSuccess Success: ");
}
}
catch (Exception)
{
this.onInitFail(obj);
}
}
/// <summary>
/// Thực thi xử lý
/// </summary>
/// <param name="context">Đối tượng context</param>
public override void ProcessExecute(HttpContext context)
{
// Khai báo biến cục bộ
var response = new BasicResponse();
// Tiến hành thực thi xử lý
switch (HandlerCom.Action) {
case "InitLayout":
response = InitLayout(context, HandlerCom.Params);
context.Response.Write(response.ToStringify());
break;
case "Save":
response = Save(context, HandlerCom.Params);
context.Response.Write(response.ToStringify());
break;
default:
break;
}
// Kết thúc response
context.Response.End();
}
public BasicResponse Save(ReportGroupItemDTO dto)
{
var response = new BasicResponse();
try
{
var entity = new ReportGroupItem()
{
Description = dto.Description,
Id = dto.Id,
Name = dto.Name,
GroupId = dto.GroupId,
ReportOrder = dto.ReportOrder,
ReportUrl = dto.ReportUrl,
IsActive = true,
};
_reportGroupItemRepository.Save(entity);
response.Status = true;
response.Info = "Success";
}
catch (Exception ex)
{
response.Status = false;
if (ex is DomainValidationException)
{
var dex = ex as DomainValidationException;
response.Info = dex.FormatException();
}
else
{
response.Status = false;
response.Info = ex.Message;
}
}
return response;
}
public BasicResponse Save(LocationDTO dto)
{
var response = new BasicResponse();
try
{
var entity = new Location
{
Code = dto.Code,
Id = dto.Id,
Name = dto.Name,
Description = dto.Description,
StructureId =(LocationStructure) dto.LocationStructureId,
IsActive = true,
};
_locationRepository.Save(entity);
response.Status = true;
response.Info = "Success";
}
catch (Exception ex)
{
response.Status = false;
if (ex is DomainValidationException)
{
var dex = ex as DomainValidationException;
response.Info = dex.FormatException();
}
else
{
response.Status = false;
response.Info = ex.Message;
}
}
return response;
}
public BasicResponse Register(RegisterDTO dto)
{
BasicResponse response = new BasicResponse();
try
{
var account = new Account()
{
Name = dto.Fullname,
Id = dto.AccountId,
IsActive = true,
CreatedOn = DateTime.Now,
UpdatedOn = DateTime.Now,
};
_accountRepository.Save(account);
var entity = new User()
{
Username = dto.Username,
Id = dto.Id,
IsActive = true,
CreatedOn = DateTime.Now,
UpdatedOn = DateTime.Now,
AccountId = dto.AccountId,
Email = dto.Email,
Fullname = dto.Fullname,
Password = dto.Password,
PhoneNumber = dto.PhoneNumber,
UserType = (UserType)dto.UserTypeId,
RegistrationType = (RegistrationType)dto.RegistrationTypeId
};
_userRepository.Save(entity);
response.Status = true;
response.Info = "Success";
}
catch (Exception ex)
{
response.Status = false;
if (ex is DomainValidationException)
{
var dex = ex as DomainValidationException;
response.Info = dex.FormatException();
}
else
{
response.Status = false;
response.Info = ex.Message;
}
}
return response;
}
public void OnConnectionDrop(BasicResponse response)
{
Debug.Log("> Client desconectado da partida com sucesso. <");
NetworkManager.singleton.StopClient();
}
public void OnMatchDestroyed(BasicResponse resp)
{
if (_disconnectServer)
{
StopMatchMaker();
StopHost();
Cursor.lockState = CursorLockMode.None;
Cursor.visible = true;
}
}
public BasicResponse AddProduct(ProductDTO dto)
{
BasicResponse response = new BasicResponse();
try
{
var account = new Product()
{
Name = dto.Name,
Id = dto.Id,
AccountId = dto.AccountId,
Description = dto.Description,
IsActive = true,
CreatedOn = DateTime.Now,
UpdatedOn = DateTime.Now,
CategoryId = dto.CategoryId,
BuyingPrice = dto.BuyingPrice,
SellingPrice = dto.SellingPrice,
};
_productRepository.Save(account);
response.Status = true;
response.Info = "Success";
}
catch (Exception ex)
{
response.Status = false;
response.Info = ex.Message;
}
return response;
}
void OnMatchDestoryed(BasicResponse response)
{
}
public void OnDestroyMatch(BasicResponse extendedInfo)
{
if (_disconnectServer)
{
StopMatchMaker();
StopHost();
}
}
public BasicResponseTests()
{
Response = new BasicResponse(CONTENT);
}
public BasicResponse SaveFormItem(FormItemDTO dto)
{
BasicResponse result = new BasicResponse();
try
{
return _formService.Save(dto);
}
catch (Exception ex)
{
result.Info = ex.Message;
}
return result;
}
public void OnMatchDestroyed(BasicResponse resp)
{
if (_disconnectServer)
{
StopMatchMaker();
StopHost();
}
}
void OnConnectionDrop(BasicResponse response) {
Debug.Log ("OnConnectionDrop()");
networkLobbyManager.StopClient ();
NetworkServer.Reset();
match = null;
switchState(nextState);
}
private void _OnDropMatch(BasicResponse response)
{
if (response.success)
{
}
}
private void _OnDestroyMatch(BasicResponse response)
{
if (response.success)
{
StopHost();
}
}
public BasicResponse PublishFormResult(DformResult formresult)
{
BasicResponse result = new BasicResponse();
try
{
if (formresult != null)
{
DformResultEntity save = new DformResultEntity();
save.Id = formresult.Id;
save.FormId = formresult.FormId;
save.RespondentTypeId = formresult.RespondentTypeId;
save.DateInserted = DateTime.UtcNow;
save.Latitude = formresult.Latitude;
save.Longitude = formresult.Longitude;
save.Username = formresult.Username;
if (formresult.LocationId.HasValue)
save.LocationId = formresult.LocationId.Value;
_context.FormResult.Add(save);
foreach (var dformResultItem in formresult.FormResultItem)
{
foreach (var ans in dformResultItem.FormItemAnswer)
{
DformResultItemEntity item = new DformResultItemEntity();
item.Id =Guid.NewGuid();
item.FormItemId = dformResultItem.FormItemId;
item.FormResultId = save.Id;
item.FormItemAnswer = ans;
_context.FormResultItem.Add(item);
}
}
_context.SaveChanges();
result.Info = "OK";
result.Status = true;
}
else
{
result.Info = "Failed";
result.Status = false;
}
}
catch (Exception ex)
{
result.Info = ex.Message;
}
return result;
}
void OnDestroyMatch(BasicResponse response) {
Debug.Log ("OnDestroyMatch()");
networkLobbyManager.StopClient ();
NetworkServer.Reset();
match = null;
switchState(nextState);
}
public BasicResponse Save(FormItemDTO dto)
{
var response = new BasicResponse();
try
{
var entity = new DformItemEntity()
{
Id = dto.Id,
FormId = dto.FormId,
HelpText = dto.HelpText,
IdCode = "",
IsRequired = dto.IsRequired,
Label = dto.Label,
Section = dto.Section,
ValidationRegex = dto.ValidationRegex,
ValidationText = dto.ValidationText,
Order = dto.Order,
FormItemType = (DformItemType)dto.FormItemTypeId,
};
_formRepository.SaveFormItem(entity);
// entity = _formRepository.QueryFormItem(new QueryFormItem {Id = entity.Id}).Result.FirstOrDefault();
_formRepository.DeleteFormItemRespondent(entity.Id);
foreach(var respondent in dto.RespondentTypes)
{
var respondentItem = new DformItemRespondentTypeEntity
{
Id = dto.Id,
FormItemId = entity.Id,
FormRespondentTypeId = respondent
};
_formRepository.SaveFormItemRespondent(respondentItem);
}
_formRepository.DeleteFormItemAnswers(entity.Id);
foreach (var ans in dto.PossibleOptions)
{
var respondentItem = new DformItemAnswerEntity()
{
Id = dto.Id,
Text =ans.Text,
FormItemId = entity.Id,
Value = ans.Value,
};
_formRepository.SaveFormItemAnswers(respondentItem);
}
response.Status = true;
response.Info = "Success";
}
catch (Exception ex)
{
response.Status = false;
if (ex is DomainValidationException)
{
var dex = ex as DomainValidationException;
response.Info = dex.FormatException();
}
else
{
response.Status = false;
response.Info = ex.Message;
}
}
return response;
}
public void OnDestroyMatch(BasicResponse response)
{
Debug.Log("> Partida destruida com sucesso. <");
NetworkManager.singleton.StopHost();
}
public static BasicResponse IsExist(string tableName, string returnColumn, List<KeyValuePair<string, object>> values)
{
BasicResponse result = new BasicResponse();
bool isFirst = true;
StringBuilder sb = new StringBuilder();
foreach (var kvp in values)
{
if (isFirst)
{
isFirst = false;
}
else
{
sb.Append(" OR ");
}
sb.Append(kvp.Key);
sb.Append(" = ");
if (kvp.Value is string)
{
sb.Append("'" + kvp.Value + "'");
}
else
{
// probably an int/long/bigint
sb.Append(kvp.Value);
}
}
string command = string.Format("select {0} from {1} where {2}", returnColumn, tableName, sb.ToString());
using (MySqlDataReader reader = DbHelper.BattleQuery(command))
{
if (reader.Read())
{
result.Param = Convert.ToInt32(reader[returnColumn]);
}
else
{
result.ErrorCode = Constants.ErrorCodes.NotExists;
}
}
return result;
}
private void OnConnectionDropped(BasicResponse response)
{
}
private void OnMatchDestroyed(BasicResponse response)
{
LobbyManager.instance.StopHost();
}
