public static IHttpActionResult AuthorizeError(this ApiController controller, ErrorTypes errorType, string error, string responseMode, Uri errorUri, string state)
{
return new AuthorizeErrorResult(new AuthorizeError
{
ErrorType = errorType,
Error = error,
ResponseMode = responseMode,
ErrorUri = errorUri,
State = state
});
}
public COBieError(string sheetName, string fieldName, string errorDescription, ErrorTypes errorType, ErrorLevels errorLevel, string initialRowHash, int column = 0, int row = 0)
{
SheetName = sheetName;
FieldName = fieldName;
ErrorDescription = errorDescription;
ErrorType = errorType;
Column = column;
Row = row;
InitialRowHash = initialRowHash;
ErrorLevel = errorLevel;
}
public void ClearCacheBegin(string sKey, AsyncCallback fAsyncCallback, object oParam)
{
m_sKey = sKey;
m_fAsyncCallback = fAsyncCallback;
m_oParam = oParam;
try
{
m_oTaskResult.RemoveBegin(m_sKey, ClearCacheTaskResultCallback, null);
}
catch
{
m_eError = ErrorTypes.Unknown;
}
}
public static int mapAscServerErrorToOldError(ErrorTypes eError)
{
int nRes = -1;
switch(eError)
{
case ErrorTypes.NoError : nRes = 0;break;
case ErrorTypes.TaskQueue :
case ErrorTypes.TaskResult : nRes = -6;break;
case ErrorTypes.ConvertDownload : nRes = -4;break;
case ErrorTypes.ConvertTimeout : nRes = -2;break;
case ErrorTypes.ConvertMS_OFFCRYPTO:
case ErrorTypes.ConvertUnknownFormat :
case ErrorTypes.ConvertReadFile :
case ErrorTypes.Convert : nRes = -3;break;
case ErrorTypes.UploadContentLength : nRes = -9;break;
case ErrorTypes.UploadExtension : nRes = -10;break;
case ErrorTypes.UploadCountFiles : nRes = -11;break;
case ErrorTypes.VKey : nRes = -8;break;
case ErrorTypes.VKeyEncrypt : nRes = -20;break;
case ErrorTypes.VKeyKeyExpire : nRes = -21;break;
case ErrorTypes.VKeyUserCountExceed : nRes = -22;break;
case ErrorTypes.Storage :
case ErrorTypes.StorageFileNoFound :
case ErrorTypes.StorageRead :
case ErrorTypes.StorageWrite :
case ErrorTypes.StorageRemoveDir :
case ErrorTypes.StorageCreateDir :
case ErrorTypes.StorageGetInfo :
case ErrorTypes.Upload :
case ErrorTypes.ReadRequestStream :
case ErrorTypes.Unknown : nRes = -1;break;
}
return nRes;
}
public async Task<IEndpointResult> CreateErrorResultAsync(ErrorTypes errorType, string error, ValidatedAuthorizeRequest request)
{
if (errorType == ErrorTypes.Client && request == null)
{
throw new ArgumentNullException(nameof(request), "Request must be passed when error type is Client.");
}
AuthorizeResponse response = null;
if (errorType == ErrorTypes.Client)
{
response = new AuthorizeResponse
{
Request = request,
IsError = true,
Error = error,
State = request.State,
RedirectUri = request.RedirectUri
};
// do some early checks to see if we will end up not generating an error page
if (error == Constants.AuthorizeErrors.AccessDenied)
{
return await CreateAuthorizeResultAsync(response);
}
if (request.PromptMode == Constants.PromptModes.None &&
request.Client.AllowPromptNone == true &&
(error == Constants.AuthorizeErrors.LoginRequired ||
error == Constants.AuthorizeErrors.ConsentRequired ||
error == Constants.AuthorizeErrors.InteractionRequired)
)
{
// todo: verify these are the right conditions to allow
// redirecting back to client
// https://tools.ietf.org/html/draft-bradley-oauth-open-redirector-00
return await CreateAuthorizeResultAsync(response);
}
else
{
//_logger.LogWarning("Rendering error page due to prompt=none, client does not allow prompt mode none, response is query, and ");
}
}
// we now know we must show error page
var msg = _localizationService.GetMessage(error);
if (msg.IsMissing())
{
msg = error;
}
var errorModel = new ErrorMessage
{
RequestId = _context.GetRequestId(),
ErrorCode = error,
ErrorDescription = msg
};
if (errorType == ErrorTypes.Client)
{
// if this is a client error, we need to build up the
// response back to the client, and provide it in the
// error view model so the UI can build the link/form
errorModel.ReturnInfo = new ClientReturnInfo
{
ClientId = request.ClientId,
};
if (request.ResponseMode == Constants.ResponseModes.Query ||
request.ResponseMode == Constants.ResponseModes.Fragment)
{
errorModel.ReturnInfo.Uri = request.RedirectUri = AuthorizeRedirectResult.BuildUri(response);
}
else if (request.ResponseMode == Constants.ResponseModes.FormPost)
{
errorModel.ReturnInfo.Uri = request.RedirectUri;
errorModel.ReturnInfo.PostBody = AuthorizeFormPostResult.BuildFormBody(response);
}
else
{
_logger.LogError("Unsupported response mode.");
throw new InvalidOperationException("Unsupported response mode");
}
}
var message = new Message<ErrorMessage>(errorModel);
await _errorMessageStore.WriteAsync(message);
return new ErrorPageResult(message.Id);
}
public LocalizedError(ErrorTypes type, string message)
{
Type = type;
Message = message;
}
public override LicenseRights getRights(LicenseMetaData metaData, out ErrorTypes errorCode)
{
LicenseRights oRights = new LicenseRights(true);
errorCode = ErrorTypes.NoError;
return oRights;
}
public ErrorMessage(ErrorTypes type, string message, int row, int col)
: this(type, message, null, null, row, col)
{
if (type != ErrorTypes.Lexical && type != ErrorTypes.Syntax)
{
throw new ArgumentException("Invalid constructor for this type of message." +
" Are you using the correct overload?");
}
}
public override void Dispose()
{
m_eError = ErrorTypes.TaskResult;
try
{
}
catch
{
}
}
public APIException(string message, ErrorTypes errorType, ErrorCodes errorCode, List <string> extraMessages)
: this(message, errorType, errorCode)
{
this.ExtraMessages = extraMessages;
}
public override void Dispose()
{
m_eError = m_eDefaultError;
Close();
}
internal OrionErrorLogInfos(String logMessage, String displayMessage, Exception sourceException, String sourceApplicationName, ErrorTypes errorType)
{
this.LogMessage = logMessage;
this.DisplayMessage = displayMessage;
this.SourceException = sourceException;
this.SourceApplicationName = sourceApplicationName;
this.LogDate = DateTime.Now;
this.ErrorType = errorType;
}// OrionErrorLogInfos()
public APIException(string message, ErrorTypes errorType)
: base(message)
{
this.ErrorType = errorType;
}
public Task <IEndpointResult> CreateErrorResultAsync(ErrorTypes errorType, string error, ValidatedAuthorizeRequest request)
{
return(Task.FromResult(ErrorResult));
}
public LocalizedError BuildError(ErrorTypes type)
{
return(new LocalizedError(type, GetErrorMessage(type)));
}
public string GetErrorMessage(ErrorTypes types)
{
return(types.ToString());
}
private ValidationResult Invalid(ErrorTypes errorType = ErrorTypes.User, string error = Constants.AuthorizeErrors.InvalidRequest)
{
var result = new ValidationResult();
result.IsError = true;
result.Error = error;
result.ErrorType = errorType;
return result;
}
public APIException(string message, ErrorTypes errorType, ErrorCodes errorCode, Exception inner)
: base(message, inner)
{
this.ErrorType = errorType;
this.ErrorCode = errorCode;
}
public ValidationResult()
{
IsError = true;
ErrorType = ErrorTypes.User;
}
/// <summary>
/// Used to Log the Custom error generated by the Managers actions.
/// It Create an ApplicationManagerException, log the developer message and return the Error.
/// </summary>
/// <param name="logger">{ILogger} The Current manager logger.</param>
/// <param name="errorType">{ErrorTypes} The Error to throw.</param>
/// <param name="logObject">{LogObject} The Values of this type are used for tracability.</param>
/// <param name="methodName">{String} The method that generated this error.</param>
/// <returns>{ApplicationManagerException} The Custom Manager Error.</returns>
public static ApplicationManagerException LogAndThrowException(this ILogger logger, ErrorTypes errorType, object logObject, [CallerMemberName] string methodName = null)
{
var ex = new ApplicationManagerException(BackendLayersNames.MANAGER, errorType, logObject, methodName: methodName);
logger.LogError($"{JsonConvert.SerializeObject(ex.ErrorResponse.DeveloperMessage)}");
return(ex);
}
}// ReportError()
/// <summary>
/// Reports an error with the specified error log message, display error message and source exception.
/// </summary>
public void ReportError(String logMessage, String displayMessage, Exception ex, ErrorTypes errorType)
{
Boolean bLogSuccessfullyReported;
Assembly xAssembly;
bLogSuccessfullyReported = false;
xAssembly = Assembly.GetEntryAssembly();
if (xAssembly == null)
{
xAssembly = Assembly.GetCallingAssembly();
}
this.ErrorLog = new OrionErrorLogInfos(logMessage, displayMessage, ex, xAssembly.GetName().Name, errorType);
//** Try using first logManager to record log, and the second first one failed. **
if (this.LogManager1 != null)
{
bLogSuccessfullyReported = this.LogManager1.LogError(this.ErrorLog);
}
if (bLogSuccessfullyReported == false && this.LogManager2 != null)
{
bLogSuccessfullyReported = this.LogManager2.LogError(this.ErrorLog);
}
Messenger.Default.Send <OrionMessageErrorReporting>(new OrionMessageErrorReporting(this.ErrorLog.ErrorType));
}// ReportError()
public ErrorContract(ErrorTypes errorType, string message)
{
ErrorType = errorType;
Message = message;
}
private ErrorMessage(ErrorTypes type, string message, SyntaxElement node,
SyntaxElement referencedNode, int row, int col)
{
ErrorType = type;
Content = message;
ProblemNode = node;
ReferencedNode = referencedNode;
Row = row;
Col = col;
}
public override LicenseRights getRights(LicenseMetaData metaData, out ErrorTypes errorCode)
{
errorCode = ErrorTypes.NoError;
LicenseRights oRights = new LicenseRights();
bool bValidLicenseFile = trackInfo.isLicenseFileValid();
if (!bValidLicenseFile)
{
errorCode = ErrorTypes.LicenseErrorFile;
bool bUnlicensedQuotaExceed = checkQuotaExceeded (metaData);
if (bUnlicensedQuotaExceed)
{
errorCode = ErrorTypes.LicenseErrorActiveConnectionQuotaExceed;
}
else
{
oRights.CanSave = true;
oRights.CanCoAuthoring = true;
oRights.CanExport = true;
}
return oRights;
}
bool bValidDate = false;
if (trackInfo.isLicenseDateValid())
{
bValidDate = true;
}
else
{
errorCode = ErrorTypes.LicenseErrorInvalidDate;
if (!trackInfo.isLicenseDateTresholdExpired())
bValidDate = true;
}
bool bBuildTimeValid = trackInfo.isLicenseEndDateGreater(m_dtBuildTime);
bool bQuotaExceed = true;
bool bEditorAllowed = false;
uint permissions = trackInfo.getLicense().getPermissions();
if ((metaData.EditorId == (int)EditorType.Convertation)
&& (permissions != EditorPermissions.PERMISSION_NONE))
{
bQuotaExceed = false;
bEditorAllowed = true;
}
else
{
bQuotaExceed = checkQuotaExceeded(metaData);
if (bQuotaExceed)
{
errorCode = ErrorTypes.LicenseErrorActiveConnectionQuotaExceed;
}
if (((metaData.EditorId == (int)EditorType.Word) && (0 != (permissions & EditorPermissions.PERMISSION_WRITER)))
|| ((metaData.EditorId == (int)EditorType.Spreadsheet) && (0 != (permissions & EditorPermissions.PERMISSION_SPREADSHEET)))
|| ((metaData.EditorId == (int)EditorType.Presentation) && (0 != (permissions & EditorPermissions.PERMISSION_PRESENTATION)))
)
{
bEditorAllowed = true;
}
else
{
}
}
if (bValidDate && bEditorAllowed && !bQuotaExceed && bBuildTimeValid)
{
oRights.CanSave = true;
oRights.CanCoAuthoring = true;
oRights.CanExport = true;
}
return oRights;
}
IHttpActionResult AuthorizeError(ErrorTypes errorType, string error, string responseMode, Uri errorUri, string state)
{
return AuthorizeError(new AuthorizeError
{
ErrorType = errorType,
Error = error,
ResponseMode = responseMode,
ErrorUri = errorUri,
State = state
});
}
protected BaseException(string message, ErrorTypes errorTypes, Exception ex)
: base(message, ex)
{
ErrorCode = (int)errorTypes;
ErrorType = errorTypes.ToString();
}
public abstract LicenseRights getRights(LicenseMetaData metaData, out ErrorTypes errorCode);
public OutputCommand(ErrorTypes eError)
{
type = "err";
data = eError.ToString("d");
}
public override LicenseRights getRights(LicenseMetaData metaData, out ErrorTypes errorCode)
{
errorCode = ErrorTypes.NoError;
LicenseRights oRights = new LicenseRights();
if (null == license
|| !license.isLicenseFound()
|| !license.isLicenseCorrect())
{
errorCode = ErrorTypes.LicenseErrorFile;
return oRights;
}
bool bValidDate = false;
DateTime now = DateTime.Now;
DateTime start = license.getStartDate();
DateTime end = license.getEndDate();
DateTime treshold = license.getEndDateThreshold();
if (start < now && end > now)
{
bValidDate = true;
}
else
{
errorCode = ErrorTypes.LicenseErrorInvalidDate;
if (now < treshold)
bValidDate = true;
}
if (bValidDate)
{
oRights.CanSave = true;
oRights.CanCoAuthoring = true;
oRights.CanExport = true;
}
return oRights;
}
async Task<IHttpActionResult> AuthorizeErrorAsync(ErrorTypes errorType, string error, ValidatedAuthorizeRequest request)
{
await RaiseFailureEventAsync(error);
// show error message to user
if (errorType == ErrorTypes.User)
{
var env = Request.GetOwinEnvironment();
var errorModel = new ErrorViewModel
{
RequestId = env.GetRequestId(),
SiteName = _options.SiteName,
SiteUrl = env.GetIdentityServerBaseUrl(),
CurrentUser = env.GetCurrentUserDisplayName(),
LogoutUrl = env.GetIdentityServerLogoutUrl(),
ErrorMessage = LookupErrorMessage(error)
};
var errorResult = new ErrorActionResult(_viewService, errorModel);
return errorResult;
}
// return error to client
var response = new AuthorizeResponse
{
Request = request,
IsError = true,
Error = error,
State = request.State,
RedirectUri = request.RedirectUri
};
if (request.ResponseMode == Constants.ResponseModes.FormPost)
{
return new AuthorizeFormPostResult(response, Request);
}
else
{
return new AuthorizeRedirectResult(response, _options);
}
}
public override LicenseRights getRights(LicenseMetaData metaData, out ErrorTypes errorCode)
{
errorCode = ErrorTypes.NoError;
LicenseRights oRights = new LicenseRights();
if (metaData is LicenseMetaData)
{
LicenseMetaData metaVKey = (LicenseMetaData)metaData;
errorCode = Signature.isAccept(metaVKey.VKey, metaVKey.DocId, false, null);
if (ErrorTypes.NoError == errorCode ||
ErrorTypes.VKeyTimeExpire == errorCode)
{
oRights.CanOpen = (ErrorTypes.VKeyTimeExpire != errorCode);
string sAffilieteId = null;
Signature.getVKeyStringParam(metaVKey.VKey, ConfigurationSettings.AppSettings["keyKeyID"], out sAffilieteId);
ASC.Core.Billing.PaymentOffice oPaymentOffice = Signature.getPaymentOffice(sAffilieteId);
if (32 <= sAffilieteId.Length)
{
oRights.CanSave = oPaymentOffice.Editing;
oRights.CanCoAuthoring = oPaymentOffice.CoEditing;
oRights.CanExport = true;
}
else
{
oRights.CanSave = true;
oRights.CanCoAuthoring = true;
oRights.CanExport = true;
}
}
}
else
{
errorCode = ErrorTypes.LicenseErrorArgument;
}
return oRights;
}
public bool HasErrorReportForNode(ErrorTypes type, SyntaxElement node)
{
return Errors.FindIndex((errMsg) => errMsg.ErrorType == type && errMsg.ProblemNode == node) > -1;
}
private AuthorizeRequestValidationResult Invalid(ValidatedAuthorizeRequest request, ErrorTypes errorType = ErrorTypes.User, string error = OidcConstants.AuthorizeErrors.InvalidRequest)
{
var result = new AuthorizeRequestValidationResult
{
IsError = true,
Error = error,
ErrorType = errorType,
ValidatedRequest = request
};
return result;
}
public bool HasErrorReportForReferenceTo(ErrorTypes type, Declaration node)
{
return Errors.FindIndex((errMsg) => errMsg.ErrorType == type && errMsg.ReferencedNode == node) > -1;
}
IHttpActionResult AuthorizeError(ErrorTypes errorType, string error, ValidatedAuthorizeRequest request)
{
RaiseFailureEvent(error);
// show error message to user
if (errorType == ErrorTypes.User)
{
var env = Request.GetOwinEnvironment();
var username = User.Identity.IsAuthenticated ? User.GetName() : (string)null;
var errorModel = new ErrorViewModel
{
RequestId = env.GetRequestId(),
SiteName = _options.SiteName,
SiteUrl = env.GetIdentityServerBaseUrl(),
CurrentUser = username,
ErrorMessage = LookupErrorMessage(error)
};
var errorResult = new ErrorActionResult(_viewService, errorModel);
return errorResult;
}
// return error to client
var response = new AuthorizeResponse
{
Request = request,
IsError = true,
Error = error,
State = request.State,
RedirectUri = request.RedirectUri
};
if (request.ResponseMode == Constants.ResponseModes.FormPost)
{
return new AuthorizeFormPostResult(response, Request);
}
else
{
return new AuthorizeRedirectResult(response);
}
}
public void ReportError(ErrorTypes type, string message, int row, int col)
{
Errors.Add(new ErrorMessage(type, message, row, col));
}
public ActionError(string errorMsg, ErrorTypes errorType)
: this()
{
this.ErrorText = errorMsg;
this.ErrorType = errorType;
}
public void ReportError(ErrorTypes type, string message,
SyntaxElement node, SyntaxElement referredNode)
{
Errors.Add(new ErrorMessage(type, message, node, referredNode));
}
public TransportClass(AsyncCallback fCallback, ErrorTypes eDefaultError, object oParam)
: base(fCallback, oParam)
{
m_eDefaultError = eDefaultError;
}
public ErrorMessage(ErrorTypes type, string message, SyntaxElement node,
SyntaxElement referencedNode)
: this(type, message, node, referencedNode, node.Row, node.Col)
{
}
public override void Dispose()
{
m_eError = ErrorTypes.NoError;
Close();
}
}// ReportError()
/// <summary>
/// Reports an error with the specified error log message and display error message.
/// </summary>
/// <remarks>No exception information will be reported. Only error messages can be retreived.</remarks>
public void ReportError(String logMessage, String displayErrorMessage, ErrorTypes errorType)
{
this.ReportError(logMessage, displayErrorMessage, null, errorType);
}// ReportError()
