public async Task <BaseResponseModel> Register(SignUpAC model)
{
if (_iAccountRepository == null)
{
_iAccountRepository = new AccountRepository();
}
var isExistUser = UserManager.FindByEmail(model.Email);
if (isExistUser == null)
{
if (await _iAccountRepository.Signup(model) == true)
{
return(StatusBuilder.ResponseSuccessStatus(null, StringConstant.SignUpSuccessfull));
}
else
{
return(StatusBuilder.ResponseFailStatus(null, StringConstant.SignUpFail));
}
}
else
{
return(StatusBuilder.ResponseFailStatus(null, "Email " + StringConstant.AlreadyExists));
}
//if (!result.Succeeded)
//{
// return GetErrorResult(result);
//}
//else
//{
// await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
//}
//return Ok();
}
public static Status FromProperties(IDictionary <string, object> statusProperties)
{
object objectCode = statusProperties[Code];
object objectMessage = statusProperties[Message];
object objectState = statusProperties[State];
if (objectCode == null && objectMessage == null && objectState == null)
{
return(null);
}
StatusBuilder statusBuilder = new StatusBuilder();
if (objectCode != null)
{
statusBuilder.Code = Escaper.Escape(objectCode.ToString());
}
if (objectMessage != null)
{
statusBuilder.Message = objectMessage.ToString();
}
if (objectState != null)
{
statusBuilder.State = objectState.ToString();
}
return(statusBuilder.Build());
}
public async Task <StatusBuilder> SendToken(ApplicationUser user, SendCodeViewModel model)
{
var output = new StatusBuilder();
// Generate the token and send it
var code = await _userManager.GenerateTwoFactorTokenAsync(user, model.SelectedProvider);
if (string.IsNullOrWhiteSpace(code))
{
output.RecordFailure("Unable to generate token");
}
else
{
var message = "Your security code is: " + code;
if (model.SelectedProvider == "Email")
{
await _emailSender.SendEmailAsync(await _userManager.GetEmailAsync(user), "Security Code", message);
}
else if (model.SelectedProvider == "Phone")
{
await _smsSender.SendSmsAsync(await _userManager.GetPhoneNumberAsync(user), message);
}
}
return(output);
}
public async Task <StatusBuilder> Disable2FA(ClaimsPrincipal principal)
{
var output = new StatusBuilder();
var user = await _userManager.GetUserAsync(principal);
if (await _userManager.GetTwoFactorEnabledAsync(user))
{
var result = await _userManager.SetTwoFactorEnabledAsync(user, false);
if (result.Succeeded)
{
output.SetMessage("2FA has been successfully disabled");
}
else
{
output.RecordFailure($"Failed to disable 2FA {result.Errors.FirstOrDefault()?.Description}");
}
}
else
{
output.RecordFailure("Cannot disable 2FA as it's not currently enabled");
}
return(output);
}
public StatusBuilder ValidateReturnUrl(HttpContext context, IUrlHelper urlHelper, String returnUrl)
{
var output = new StatusBuilder();
if (string.IsNullOrEmpty(returnUrl))
{
returnUrl = "~/";
}
var redirectDetails = new RedirectUrlDetails();
redirectDetails.IsLocal = false;
if (_interaction.IsValidReturnUrl(redirectDetails.Url) || urlHelper.IsLocalUrl(redirectDetails.Url))
{
redirectDetails.IsLocal = true;
}
// validate returnUrl - either it is a valid OIDC URL or back to a local page
else if (urlHelper.IsLocalUrl(returnUrl) == false && _interaction.IsValidReturnUrl(returnUrl) == false)
{
// user might have clicked on a malicious link - should be logged
output.RecordFailure("Invalid return URL - Possible malicious Link.");
}
return(output);
}
public virtual async Task <StatusBuilder> LoginAsync(LoginDetails details)
{
var output = new StatusBuilder();
var results = new LoginResults();
results.User = await _userManager.FindByNameAsync(details.Username);
if (results.User != null)
{
var passwordValid = await _userManager.CheckPasswordAsync(results.User, details.Password);
if (passwordValid)
{
results.Result = await _signInManager.PasswordSignInAsync(details.Username, details.Password, true, lockoutOnFailure : false);
}
else
{
// It's an invalid password, but include both username and password to lower hacking attempts
output.RecordFailure("Invalid Password or Username");
}
}
else
{
// It's an invalid username, but include both username and password to lower hacking attempts
output.RecordFailure("Invalid Username or Password");
}
output.SetData(results);
return(output);
}
public void GetEnvelopStatusTest()
{
IStatusBuilder builder = new StatusBuilder(_api, new JsonConfiguration());
IResponse response;
Assert.IsTrue(builder.Build("5058294f-25d3-4da4-9cb7-926d95dc66b1", _username, _password, out response));
Assert.AreEqual("completed", ((EnvelopeStatus)response.Data).Status);
}
public Program()
{
GetLayers();
StatusBuilder.Clear();
foreach (var x in BlocksPerLayer)
{
StatusBuilder.AppendLine(x.ToString());
}
Me.CustomData = StatusBuilder.ToString();
}
public async Task <BaseResponse> SignupAsync(UserDetailDTO userDetail)
{
try
{
return(await _iAccountRepository.SignUpAsync(userDetail));
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(StatusBuilder.ResponseFailStatus(null, ex.Message));
}
}
// Returns true or fale if windows login is successful, on true, it returns the redirect URL
public async Task <StatusBuilder> ProcessWindowsLoginAsync(HttpContext context, IUrlHelper urlHelper, string returnUrl)
{
var output = new StatusBuilder();
// see if windows auth has already been requested and succeeded
var result = await context.AuthenticateAsync(AccountOptions.WindowsAuthenticationSchemeName);
if (result?.Principal is WindowsPrincipal wp)
{
// we will issue the external cookie and then redirect the
// user back to the external callback, in essence, treating windows
// auth the same as any other external authentication mechanism
var props = new AuthenticationProperties()
{
RedirectUri = urlHelper.Action("Callback"),
Items =
{
{ "returnUrl", returnUrl },
{ "scheme", AccountOptions.WindowsAuthenticationSchemeName },
}
};
var id = new ClaimsIdentity(AccountOptions.WindowsAuthenticationSchemeName);
id.AddClaim(new Claim(JwtClaimTypes.Subject, wp.Identity.Name));
id.AddClaim(new Claim(JwtClaimTypes.Name, wp.Identity.Name));
// add the groups as claims -- be careful if the number of groups is too large
if (AccountOptions.IncludeWindowsGroups)
{
var wi = wp.Identity as WindowsIdentity;
var groups = wi.Groups.Translate(typeof(NTAccount));
var roles = groups.Select(x => new Claim(JwtClaimTypes.Role, x.Value));
id.AddClaims(roles);
}
await context.SignInAsync(
IdentityServer4.IdentityServerConstants.ExternalCookieAuthenticationScheme,
new ClaimsPrincipal(id),
props);
output.SetData(props.RedirectUri);
}
else
{
output.Fail();
}
return(output);
}
/// <summary>
/// This method is use for new user signup
/// </summary>
/// <param name="userDetailDTO"></param>
/// <returns></returns>
public async Task <BaseResponse> SignUpAsync(UserDetailDTO userDetailDTO)
{
try
{
//string ConnectionString = _config[_iStringConstants.MyConnectionString];
BaseResponse baseResponse = new BaseResponse();
UserTokenDTO userTokenAC = new UserTokenDTO();
using (DeepakdbContext deepakDBContext = new DeepakdbContext())
{
//deepakDBContext.Query<T>().AsTracking().
var data = await Task.Run(() => deepakDBContext
.Database.ExecuteSqlRaw("spInsertUserDetail @FirstName=@p0, @LastName=@p1,@Email=@p2,@Password=@p3,@MobileNumber=@p4,@Address_Line1=@p5,@Address_Line2=@p6, @ZipCode=@p7, @CreatedBy=@p8",
parameters: new [] { userDetailDTO.FirstName, userDetailDTO.LastName, userDetailDTO.Email,
PasswordHashUtill.HashPassword(userDetailDTO.Password), userDetailDTO.MobileNumber,
userDetailDTO.AddressLine1, userDetailDTO.AddressLine2, userDetailDTO.ZipCode.ToString(),
userDetailDTO.CreatedBy }
/*new SqlParameter("@FirstName", userDetailDTO.FirstName),
* new SqlParameter("@LastName", userDetailDTO.FirstName),
* new SqlParameter("@Email", userDetailDTO.Email),
* new SqlParameter("@Password",PasswordHashUtill.HashPassword( userDetailDTO.Password)),
* new SqlParameter("@MobileNumber", userDetailDTO.MobileNumber),
* new SqlParameter("@Address_Line1", userDetailDTO.AddressLine1),
* new SqlParameter("@Address_Line2", userDetailDTO.AddressLine2),
* new SqlParameter("@ZipCode", userDetailDTO.ZipCode),
* new SqlParameter("@CreatedBy", userDetailDTO.CreatedBy)*/
));
if (data != null)
{
baseResponse.StatusCode = 1;
baseResponse.Message = _iStringConstants.AddedSuccessfully;
// Need to ask how to get DBCONTEXT status code from store procedure
}
if (baseResponse.StatusCode == 1)
{
return(StatusBuilder.ResponseSuccessStatus(null, baseResponse.Message));
}
return(StatusBuilder.ResponseFailStatus(null, baseResponse.Message));
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <StatusBuilder> ResetAuthenticator(ClaimsPrincipal principal)
{
var output = new StatusBuilder();
var user = await _userManager.GetUserAsync(principal);
await _userManager.SetTwoFactorEnabledAsync(user, false);
await _userManager.ResetAuthenticatorKeyAsync(user);
await _signInManager.RefreshSignInAsync(user);
output.SetMessage("Your authenticator app key has been reset, you will need to configure your authenticator app using the new key.");
return(output);
}
private async Task <PNResult <PNPublishFileMessageResult> > PublishFileMessage(object message, Dictionary <string, object> externalQueryParam)
{
PNResult <PNPublishFileMessageResult> ret = new PNResult <PNPublishFileMessageResult>();
IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : "");
Uri request = urlBuilder.BuildPublishFileMessageRequest("GET", "", this.channelName, message, this.storeInHistory, this.ttl, this.userMetadata, null, externalQueryParam);
RequestState <PNPublishFileMessageResult> requestState = new RequestState <PNPublishFileMessageResult>();
requestState.Channels = new[] { this.channelName };
requestState.ResponseType = PNOperationType.PNPublishFileMessageOperation;
requestState.PubnubCallback = null;
requestState.Reconnect = false;
requestState.EndPointOperation = this;
string json = "";
await UrlProcessRequest(request, requestState, false).ContinueWith(r =>
{
json = r.Result.Item1;
if (!string.IsNullOrEmpty(json))
{
List <object> result = ProcessJsonResponse(requestState, json);
ResponseBuilder responseBuilder = new ResponseBuilder(config, jsonLibrary, pubnubLog);
PNPublishFileMessageResult publishResult = responseBuilder.JsonToObject <PNPublishFileMessageResult>(result, true);
StatusBuilder statusBuilder = new StatusBuilder(config, jsonLibrary);
if (publishResult != null)
{
ret.Result = publishResult;
PNStatus status = statusBuilder.CreateStatusResponse(requestState.ResponseType, PNStatusCategory.PNAcknowledgmentCategory, requestState, (int)HttpStatusCode.OK, null);
ret.Status = status;
}
else
{
PNException ex = new PNException("File has been upload but the notification couldn't be sent to the subscribed users");
PNStatus status = statusBuilder.CreateStatusResponse(requestState.ResponseType, PNStatusCategory.PNUnknownCategory, requestState, (int)HttpStatusCode.BadRequest, ex);
status.AdditonalData = new Dictionary <string, string> {
{ "FileId", currentFileId }, { "FileName", sendFileName }
};
ret.Status = status;
}
}
}, TaskContinuationOptions.ExecuteSynchronously);
return(ret);
}
public async Task <StatusBuilder> Validate2faUser()
{
var output = new StatusBuilder();
var user = await _signInManager.GetTwoFactorAuthenticationUserAsync();
if (user == null)
{
output.RecordFailure("Unable to load two-factor authentication user");
}
else
{
output.SetData(user);
}
return(output);
}
private static Entry newEntry(IList <string> parentPath, long timestamp, string text)
{
EntryBuilder entryBuilder = new EntryBuilder(parentPath, timestamp);
try
{
double?value = double.Parse(text);
entryBuilder.Value = value;
}
catch (System.Exception e)
{
StatusBuilder sb = new StatusBuilder();
sb.Message = text;
entryBuilder.Status = sb.Build();
}
return(entryBuilder.Build());
}
public async Task <StatusBuilder> RegisterAsync(RegistrationDetails details)
{
var output = new StatusBuilder();
var user = await _userManager.FindByNameAsync(details.Username);
if (user == null)
{
user = new ApplicationUser {
Id = Guid.NewGuid().ToString(),
UserName = details.Username,
Email = details.Email
};
output.SetData(user);
var identityResult = await _userManager.CreateAsync(user, details.Password);
if (identityResult.Succeeded)
{
if (details.StartFreeTrial)
{
var trialClaim = new Claim("Trial", DateTime.Now.ToString());
await _userManager.AddClaimAsync(user, trialClaim);
}
else if (details.IsAdmin)
{
await _userManager.AddToRoleAsync(user, "Admin");
}
}
else
{
foreach (var err in identityResult.Errors)
{
output.RecordFailure(err.Description, err.Code);
}
}
}
else
{
output.RecordFailure("User already exists");
}
return(output);
}
public static Status NewStatus(string code, string message, string state)
{
StatusBuilder statusBuilder = new StatusBuilder();
if (!System.String.IsNullOrEmpty(code))
{
statusBuilder.Code = Escaper.Escape(code);
}
if (!System.String.IsNullOrEmpty(message))
{
statusBuilder.Message = Escaper.Escape(message);
}
if (!System.String.IsNullOrEmpty(state))
{
statusBuilder.State = state;
}
return(statusBuilder.Build());
}
/// <summary>
/// The status is set to {@code Status.State.FAIL} if {@code exception} is not null. The message is set to the message
/// from the exception if there is one. </summary>
/// <param name="code"> </param>
/// <param name="exception">
/// @return </param>
public static Status NewStatus(string code, Exception exception)
{
StatusBuilder statusBuilder = new StatusBuilder();
if (!System.String.IsNullOrEmpty(code))
{
statusBuilder.Code = Escaper.Escape(code);
}
if (exception != null)
{
statusBuilder.State = Status.State.Fail;
statusBuilder.Message = exception.Message;
}
else
{
statusBuilder.State = Status.State.Pass;
}
return(statusBuilder.Build());
}
public async Task <BaseResponse> UpdateProfileAsync(UserProfileDTO userProfileDTO, long longloggedInUserId)
{
try
{
BaseResponse baseResponse = new BaseResponse();
UserTokenDTO userTokenAC = new UserTokenDTO();
using (DeepakdbContext deepakDBContext = new DeepakdbContext())
{
var data = await Task.Run(() => deepakDBContext
.UserDetail.FromSqlRaw("spUpdateUserDetail",
new SqlParameter("@Id", userProfileDTO.Id),
new SqlParameter("@FirstName", userProfileDTO.FirstName),
new SqlParameter("@LastName", userProfileDTO.LastName),
new SqlParameter("@Email", userProfileDTO.Email),
new SqlParameter("@MobileNumber", userProfileDTO.MobileNumber),
new SqlParameter("@Address_Line1", userProfileDTO.AddressLine1),
new SqlParameter("@Address_Line2", userProfileDTO.AddressLine2),
new SqlParameter("@ZipCode", userProfileDTO.ZipCode),
new SqlParameter("@@LoggedInUserId", longloggedInUserId)
)
);
if (data != null)
{
baseResponse.StatusCode = 1;
baseResponse.Message = _iStringConstants.AddedSuccessfully;
// Need to ask how to get DBCONTEXT status code from store procedure
}
if (baseResponse.StatusCode == 1)
{
return(StatusBuilder.ResponseSuccessStatus(null, baseResponse.Message));
}
return(StatusBuilder.ResponseFailStatus(null, baseResponse.Message));
}
}
catch (Exception ex)
{
throw ex;
}
}
// The data returned by the status builder upon success is any available recovery codes
public async Task <StatusBuilder> VerifyAuthenticatorCode(ClaimsPrincipal principal, VerificationCodeDetails code)
{
var output = new StatusBuilder();
var user = await _userManager.GetUserAsync(principal);
var verificationCode = code.VerificationCode.Replace(" ", string.Empty).Replace("-", string.Empty);
var is2FaTokenValid = await _userManager.VerifyTwoFactorTokenAsync(user, _userManager.Options.Tokens.AuthenticatorTokenProvider, verificationCode);
if (is2FaTokenValid)
{
var results = await _userManager.SetTwoFactorEnabledAsync(user, true);
if (results.Succeeded)
{
output.SetMessage("Your authenticator app has been verified");
if (await _userManager.CountRecoveryCodesAsync(user) == 0)
{
var recoveryCodes = await _userManager.GenerateNewTwoFactorRecoveryCodesAsync(user, 10);
output.SetData(recoveryCodes.ToList());
}
}
else
{
foreach (var err in results.Errors)
{
output.RecordFailure(err.Description, err.Code);
}
}
}
else
{
output.RecordFailure("Verification code is invalid");
}
return(output);
}
public async Task <StatusBuilder> GenerateRecoveryCodes(ClaimsPrincipal principal)
{
var output = new StatusBuilder();
var user = await _userManager.GetUserAsync(principal);
var isTwoFactorEnabled = await _userManager.GetTwoFactorEnabledAsync(user);
if (isTwoFactorEnabled)
{
var recoveryCodes = await _userManager.GenerateNewTwoFactorRecoveryCodesAsync(user, 10);
output.SetMessage("You have generated new recovery codes")
.SetData(recoveryCodes.ToList());
}
else
{
output.RecordFailure("Cannot generate recovery codes as you do not have 2FA enabled");
}
return(output);
}
protected override void _Execute(params object[] args)
{
Collection <Route> selected = new Collection <Route>();
foreach (Route item in _GetRoutesFromSelection())
{
Route route = item.CloneNoResults() as Route;
route.Vehicle = null;
route.Driver = null;
route.DefaultRouteID = null;
selected.Add(route);
}
foreach (Route item in selected)
{
item.Name = DataObjectNamesConstructor.GetDuplicateName(item.Name, CurrentSchedule.Routes);
CurrentSchedule.Routes.Add(item);
}
App.Current.Project.Save();
StatusBuilder statusBuilder = new StatusBuilder();
statusBuilder.FillSelectionStatusWithoutCollectionSize(CurrentSchedule.Routes.Count, (string)App.Current.FindResource("Route"), 0, OptimizePage);
}
protected override void _Execute(params object[] args)
{
Collection <Order> selectedOrders = new Collection <Order>();
foreach (Order order in _GetUnassignedOrdersFromSelection())
{
Order newOrder = order.Clone() as Order;
selectedOrders.Add(newOrder);
}
Project project = App.Current.Project;
foreach (Order order in selectedOrders)
{
order.Name = DataObjectNamesConstructor.GetDuplicateName(order.Name, _GetUnassignedOrdersFromSelection());
project.Orders.Add(order);
}
project.Save();
StatusBuilder statusBuilder = new StatusBuilder();
statusBuilder.FillSelectionStatusWithoutCollectionSize(CurrentSchedule.UnassignedOrders.Count, (string)App.Current.FindResource("Order"), 0, OptimizePage);
}
private void Signal(string channel, object message, Dictionary <string, object> metaData, Dictionary <string, object> externalQueryParam, PNCallback <PNPublishResult> callback)
{
if (string.IsNullOrEmpty(channel) || string.IsNullOrEmpty(channel.Trim()) || message == null)
{
PNStatus status = new PNStatus {
Error = true, ErrorData = new PNErrorData("Missing Channel or Message", new ArgumentException("Missing Channel or Message"))
};
callback.OnResponse(null, status);
return;
}
if (string.IsNullOrEmpty(config.PublishKey) || string.IsNullOrEmpty(config.PublishKey.Trim()) || config.PublishKey.Length <= 0)
{
PNStatus status = new PNStatus {
Error = true, ErrorData = new PNErrorData("Invalid publish key", new ArgumentException("Invalid publish key"))
};
callback.OnResponse(null, status);
return;
}
if (string.IsNullOrEmpty(config.SubscribeKey) || string.IsNullOrEmpty(config.SubscribeKey.Trim()) || config.SubscribeKey.Length <= 0)
{
PNStatus status = new PNStatus {
Error = true, ErrorData = new PNErrorData("Invalid subscribe key", new ArgumentException("Invalid subscribe key"))
};
callback.OnResponse(null, status);
return;
}
IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : "");
Uri request = urlBuilder.BuildSignalRequest("GET", "", channel, message, metaData, externalQueryParam);
RequestState <PNPublishResult> requestState = new RequestState <PNPublishResult>();
requestState.Channels = new[] { channel };
requestState.ResponseType = PNOperationType.PNSignalOperation;
requestState.PubnubCallback = callback;
requestState.Reconnect = false;
requestState.EndPointOperation = this;
UrlProcessRequest(request, requestState, false).ContinueWith(r =>
{
string json = r.Result.Item1;
if (!string.IsNullOrEmpty(json))
{
List <object> result = ProcessJsonResponse(requestState, json);
if (result != null && result.Count >= 3)
{
int signalStatus;
Int32.TryParse(result[0].ToString(), out signalStatus);
if (signalStatus == 1)
{
ProcessResponseCallbacks(result, requestState);
}
else
{
PNStatusCategory category = PNStatusCategoryHelper.GetPNStatusCategory(400, result[1].ToString());
PNStatus status = new StatusBuilder(config, jsonLibrary).CreateStatusResponse <PNPublishResult>(PNOperationType.PNSignalOperation, category, requestState, 400, new PNException(json));
if (requestState.PubnubCallback != null)
{
requestState.PubnubCallback.OnResponse(default(PNPublishResult), status);
}
}
}
else
{
ProcessResponseCallbacks(result, requestState);
}
}
}, TaskContinuationOptions.ExecuteSynchronously).Wait();
}
private async Task <PNResult <PNPublishResult> > Signal(string channel, object message, Dictionary <string, object> metaData, Dictionary <string, object> externalQueryParam)
{
PNResult <PNPublishResult> ret = new PNResult <PNPublishResult>();
if (string.IsNullOrEmpty(channel) || string.IsNullOrEmpty(channel.Trim()) || message == null)
{
PNStatus errStatus = new PNStatus {
Error = true, ErrorData = new PNErrorData("Missing Channel or Message", new ArgumentException("Missing Channel or Message"))
};
ret.Status = errStatus;
return(ret);
}
if (string.IsNullOrEmpty(config.PublishKey) || string.IsNullOrEmpty(config.PublishKey.Trim()) || config.PublishKey.Length <= 0)
{
PNStatus errStatus = new PNStatus {
Error = true, ErrorData = new PNErrorData("Invalid publish key", new ArgumentException("Invalid publish key"))
};
ret.Status = errStatus;
return(ret);
}
if (string.IsNullOrEmpty(config.SubscribeKey) || string.IsNullOrEmpty(config.SubscribeKey.Trim()) || config.SubscribeKey.Length <= 0)
{
PNStatus errStatus = new PNStatus {
Error = true, ErrorData = new PNErrorData("Invalid subscribe key", new ArgumentException("Invalid subscribe key"))
};
ret.Status = errStatus;
return(ret);
}
IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : "");
Uri request = urlBuilder.BuildSignalRequest("GET", "", channel, message, metaData, externalQueryParam);
RequestState <PNPublishResult> requestState = new RequestState <PNPublishResult>();
requestState.Channels = new[] { channel };
requestState.ResponseType = PNOperationType.PNSignalOperation;
requestState.Reconnect = false;
requestState.EndPointOperation = this;
Tuple <string, PNStatus> JsonAndStatusTuple = await UrlProcessRequest(request, requestState, false).ConfigureAwait(false);
ret.Status = JsonAndStatusTuple.Item2;
string json = JsonAndStatusTuple.Item1;
if (!string.IsNullOrEmpty(json))
{
List <object> result = ProcessJsonResponse <PNPublishResult>(requestState, json);
if (result != null && result.Count >= 3)
{
int publishStatus;
Int32.TryParse(result[0].ToString(), out publishStatus);
if (publishStatus == 1)
{
List <object> resultList = ProcessJsonResponse(requestState, json);
if (resultList != null && resultList.Count > 0)
{
ResponseBuilder responseBuilder = new ResponseBuilder(config, jsonLibrary, pubnubLog);
PNPublishResult responseResult = responseBuilder.JsonToObject <PNPublishResult>(resultList, true);
if (responseResult != null)
{
ret.Result = responseResult;
}
}
else
{
PNStatusCategory category = PNStatusCategoryHelper.GetPNStatusCategory(400, result[1].ToString());
PNStatus status = new StatusBuilder(config, jsonLibrary).CreateStatusResponse <PNPublishResult>(PNOperationType.PNSignalOperation, category, requestState, 400, new PNException(json));
ret.Status = status;
ret.Result = default(PNPublishResult);
}
}
}
}
return(ret);
}
private void Fire(string channel, object message, bool storeInHistory, int ttl, Dictionary <string, object> metaData, Dictionary <string, object> externalQueryParam, PNCallback <PNPublishResult> callback)
{
if (string.IsNullOrEmpty(channel) || string.IsNullOrEmpty(channel.Trim()) || message == null)
{
PNStatus status = new PNStatus {
Error = true, ErrorData = new PNErrorData("Missing Channel or Message", new ArgumentException("Missing Channel or Message"))
};
callback.OnResponse(null, status);
return;
}
if (string.IsNullOrEmpty(config.PublishKey) || string.IsNullOrEmpty(config.PublishKey.Trim()) || config.PublishKey.Length <= 0)
{
PNStatus status = new PNStatus {
Error = true, ErrorData = new PNErrorData("Invalid publish key", new ArgumentException("Invalid publish key"))
};
callback.OnResponse(null, status);
return;
}
if (callback == null)
{
return;
}
Dictionary <string, string> urlParam = new Dictionary <string, string>();
urlParam.Add("norep", "true");
string requestMethodName = (this.httpPost) ? "POST" : "GET";
IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : "");
Uri request = urlBuilder.BuildPublishRequest(requestMethodName, "", channel, message, storeInHistory, ttl, metaData, urlParam, externalQueryParam);
RequestState <PNPublishResult> requestState = new RequestState <PNPublishResult>();
requestState.Channels = new [] { channel };
requestState.ResponseType = PNOperationType.PNFireOperation;
requestState.PubnubCallback = callback;
requestState.Reconnect = false;
requestState.EndPointOperation = this;
string json = "";
if (this.httpPost)
{
requestState.UsePostMethod = true;
Dictionary <string, object> messageEnvelope = new Dictionary <string, object>();
messageEnvelope.Add("message", message);
string postMessage = jsonLibrary.SerializeToJsonString(messageEnvelope);
UrlProcessRequest(request, requestState, false, postMessage).ContinueWith(r =>
{
json = r.Result.Item1;
}, TaskContinuationOptions.ExecuteSynchronously).Wait();
}
else
{
UrlProcessRequest(request, requestState, false).ContinueWith(r =>
{
json = r.Result.Item1;
}, TaskContinuationOptions.ExecuteSynchronously).Wait();
}
if (!string.IsNullOrEmpty(json))
{
List <object> result = ProcessJsonResponse <PNPublishResult>(requestState, json);
if (result != null && result.Count >= 3)
{
int publishStatus;
Int32.TryParse(result[0].ToString(), out publishStatus);
if (publishStatus == 1)
{
ProcessResponseCallbacks(result, requestState);
}
else
{
PNStatusCategory category = PNStatusCategoryHelper.GetPNStatusCategory(400, result[1].ToString());
PNStatus status = new StatusBuilder(config, jsonLibrary).CreateStatusResponse <PNPublishResult>(PNOperationType.PNFireOperation, category, requestState, 400, new PNException(json));
if (requestState.PubnubCallback != null)
{
requestState.PubnubCallback.OnResponse(default(PNPublishResult), status);
}
}
}
else
{
ProcessResponseCallbacks(result, requestState);
}
}
}
public StatusBuilderDirector(StatusBuilder builder)
{
this.builder = builder;
}
internal void SetUserState(string[] channels, string[] channelGroups, string uuid, string jsonUserState, PNCallback <PNSetStateResult> callback)
{
if ((channels == null && channelGroups == null) ||
(channels != null && channelGroups != null && channels.Length == 0 && channelGroups.Length == 0))
{
throw new ArgumentException("Either Channel Or Channel Group or Both should be provided");
}
if (string.IsNullOrEmpty(jsonUserState) || string.IsNullOrEmpty(jsonUserState.Trim()))
{
throw new ArgumentException("Missing User State");
}
List <string> channelList = new List <string>();
List <string> channelGroupList = new List <string>();
if (channels != null && channels.Length > 0)
{
channelList = new List <string>(channels);
channelList = channelList.Where(ch => !string.IsNullOrEmpty(ch) && ch.Trim().Length > 0).Distinct <string>().ToList();
channels = channelList.ToArray();
}
if (channelGroups != null && channelGroups.Length > 0)
{
channelGroupList = new List <string>(channelGroups);
channelGroupList = channelGroupList.Where(cg => !string.IsNullOrEmpty(cg) && cg.Trim().Length > 0).Distinct <string>().ToList();
channelGroups = channelGroupList.ToArray();
}
string commaDelimitedChannel = (channels != null && channels.Length > 0) ? string.Join(",", channels.OrderBy(x => x).ToArray()) : "";
string commaDelimitedChannelGroup = (channelGroups != null && channelGroups.Length > 0) ? string.Join(",", channelGroups.OrderBy(x => x).ToArray()) : "";
if (!jsonLibrary.IsDictionaryCompatible(jsonUserState))
{
throw new MissingMemberException("Missing json format for user state");
}
else
{
Dictionary <string, object> deserializeUserState = jsonLibrary.DeserializeToDictionaryOfObject(jsonUserState);
if (deserializeUserState == null)
{
throw new MissingMemberException("Missing json format user state");
}
else
{
bool stateChanged = false;
for (int channelIndex = 0; channelIndex < channelList.Count; channelIndex++)
{
string currentChannel = channelList[channelIndex];
string oldJsonChannelState = GetLocalUserState(currentChannel, "");
if (oldJsonChannelState != jsonUserState)
{
stateChanged = true;
break;
}
}
if (!stateChanged)
{
for (int channelGroupIndex = 0; channelGroupIndex < channelGroupList.Count; channelGroupIndex++)
{
string currentChannelGroup = channelGroupList[channelGroupIndex];
string oldJsonChannelGroupState = GetLocalUserState("", currentChannelGroup);
if (oldJsonChannelGroupState != jsonUserState)
{
stateChanged = true;
break;
}
}
}
if (!stateChanged)
{
StatusBuilder statusBuilder = new StatusBuilder(config, jsonLibrary);
PNStatus status = statusBuilder.CreateStatusResponse <PNSetStateResult>(PNOperationType.PNSetStateOperation, PNStatusCategory.PNUnknownCategory, null, (int)System.Net.HttpStatusCode.NotModified, null);
Announce(status);
return;
}
}
}
SharedSetUserState(channels, channelGroups, uuid, jsonUserState, jsonUserState, callback);
}
internal void SetUserState(string[] channels, string[] channelGroups, string uuid, KeyValuePair <string, object> keyValuePair, PNCallback <PNSetStateResult> callback)
{
if ((channels == null && channelGroups != null) || (channels.Length == 0 && channelGroups.Length == 0))
{
throw new ArgumentException("Either Channel Or Channel Group or Both should be provided.");
}
List <string> channelList = new List <string>();
List <string> channelGroupList = new List <string>();
if (channels != null && channels.Length > 0)
{
channelList = new List <string>(channels);
channelList = channelList.Where(ch => !string.IsNullOrEmpty(ch) && ch.Trim().Length > 0).Distinct <string>().ToList();
channels = channelList.ToArray();
}
if (channelGroups != null && channelGroups.Length > 0)
{
channelGroupList = new List <string>(channelGroups);
channelGroupList = channelGroupList.Where(cg => !string.IsNullOrEmpty(cg) && cg.Trim().Length > 0).Distinct <string>().ToList();
channelGroups = channelGroupList.ToArray();
}
string commaDelimitedChannel = (channels != null && channels.Length > 0) ? string.Join(",", channels.OrderBy(x => x).ToArray()) : "";
string commaDelimitedChannelGroup = (channelGroups != null && channelGroups.Length > 0) ? string.Join(",", channelGroups.OrderBy(x => x).ToArray()) : "";
string key = keyValuePair.Key;
int valueInt;
double valueDouble;
bool stateChanged = false;
string currentChannelUserState = "";
string currentChannelGroupUserState = "";
for (int channelIndex = 0; channelIndex < channelList.Count; channelIndex++)
{
string currentChannel = channelList[channelIndex];
string oldJsonChannelState = GetLocalUserState(currentChannel, "");
currentChannelUserState = "";
if (keyValuePair.Value == null)
{
currentChannelUserState = SetLocalUserState(currentChannel, "", key, null);
}
else if (Int32.TryParse(keyValuePair.Value.ToString(), out valueInt))
{
currentChannelUserState = SetLocalUserState(currentChannel, "", key, valueInt);
}
else if (Double.TryParse(keyValuePair.Value.ToString(), out valueDouble))
{
currentChannelUserState = SetLocalUserState(currentChannel, "", key, valueDouble);
}
else
{
currentChannelUserState = SetLocalUserState(currentChannel, "", key, keyValuePair.Value.ToString());
}
if (oldJsonChannelState != currentChannelUserState)
{
stateChanged = true;
break;
}
}
if (!stateChanged)
{
for (int channelGroupIndex = 0; channelGroupIndex < channelGroupList.Count; channelGroupIndex++)
{
string currentChannelGroup = channelGroupList[channelGroupIndex];
string oldJsonChannelGroupState = GetLocalUserState("", currentChannelGroup);
currentChannelGroupUserState = "";
if (keyValuePair.Value == null)
{
currentChannelGroupUserState = SetLocalUserState("", currentChannelGroup, key, null);
}
else if (Int32.TryParse(keyValuePair.Value.ToString(), out valueInt))
{
currentChannelGroupUserState = SetLocalUserState("", currentChannelGroup, key, valueInt);
}
else if (Double.TryParse(keyValuePair.Value.ToString(), out valueDouble))
{
currentChannelGroupUserState = SetLocalUserState("", currentChannelGroup, key, valueDouble);
}
else
{
currentChannelGroupUserState = SetLocalUserState("", currentChannelGroup, key, keyValuePair.Value.ToString());
}
if (oldJsonChannelGroupState != currentChannelGroupUserState)
{
stateChanged = true;
break;
}
}
}
if (!stateChanged)
{
StatusBuilder statusBuilder = new StatusBuilder(config, jsonLibrary);
PNStatus status = statusBuilder.CreateStatusResponse <PNSetStateResult>(PNOperationType.PNSetStateOperation, PNStatusCategory.PNUnknownCategory, null, (int)System.Net.HttpStatusCode.NotModified, null);
Announce(status);
return;
}
if (currentChannelUserState.Trim() == "")
{
currentChannelUserState = "{}";
}
if (currentChannelGroupUserState == "")
{
currentChannelGroupUserState = "{}";
}
SharedSetUserState(channels, channelGroups, uuid, currentChannelUserState, currentChannelGroupUserState, callback);
}
public Program()
{
Runtime.UpdateFrequency = UpdateFrequency.Update100;
GridTerminalSystem.GetBlocksOfType <IMyTerminalBlock>(null, CollectParts);
StatusBuilder.Clear();
var AOK = true;
if (SmallHinge == null)
{
AOK = false;
StatusBuilder.AppendLine("SMALL HINGE NOT FOUND!");
}
if (LargeHinge == null)
{
AOK = false;
StatusBuilder.AppendLine("LARGE HINGE NOT FOUND!");
}
if (Sweeper == null)
{
AOK = false;
StatusBuilder.AppendLine("SWEEPER NOT FOUND!");
}
if (BaseProjector == null)
{
AOK = false;
StatusBuilder.AppendLine("BASE PROJECTOR NOT FOUND!");
}
if (TopProjector == null)
{
AOK = false;
StatusBuilder.AppendLine("TOP PROJECTOR NOT FOUND!");
}
if (TopMerge == null)
{
AOK = false;
StatusBuilder.AppendLine("TOP MERGE NOT FOUND!");
}
if (BaseMerge == null)
{
AOK = false;
StatusBuilder.AppendLine("BASE MERGE NOT FOUND!");
}
if (Welders.Count < 5)
{
AOK = false;
StatusBuilder.AppendLine("NOT ENOUGH WELDERS!");
}
if (Display != null)
{
Display.ContentType = ContentType.TEXT_AND_IMAGE;
Display.WriteText(StatusBuilder.ToString());
}
if (!AOK)
{
Echo(StatusBuilder.ToString());
Runtime.UpdateFrequency = UpdateFrequency.None;
}
else
{
var baseOtherMerge = GridTerminalHelper.OtherMergeBlock(BaseMerge);
var topOtherMerge = GridTerminalHelper.OtherMergeBlock(TopMerge);
if (topOtherMerge != null && baseOtherMerge == null)
{
State = 4;
}
}
ReleaseListener = IGC.RegisterBroadcastListener("[PDCFORGE]");
ReleaseListener.SetMessageCallback("release");
}
