public SearchIndexResponseFactory(ISerializer serializer, IEntitySerializer entitySerializer)
: base(serializer)
{
Ensure.That(entitySerializer, "entitySerializer").IsNotNull();
EntitySerializer = entitySerializer;
}
/// <summary>
/// 显示摊销及其计算表
/// </summary>
/// <param name="amort">摊销</param>
/// <param name="serializer">表示器</param>
/// <param name="dt">计算账面价值的时间</param>
/// <param name="showSchedule">是否显示计算表</param>
/// <returns>格式化的信息</returns>
private string ListAmort(Amortization amort, IEntitySerializer serializer, DateTime?dt = null,
bool showSchedule = true)
{
var sb = new StringBuilder();
var bookValue = Accountant.GetBookValueOn(amort, dt);
if (dt.HasValue &&
!bookValue?.IsZero() != true)
{
return(null);
}
sb.AppendLine(
$"{amort.StringID} {amort.Name.CPadRight(35)}{amort.Date:yyyyMMdd}" +
$"U{amort.User.AsUser().CPadRight(5)} " +
$"{amort.Value.AsCurrency().CPadLeft(13)}{(dt.HasValue ? bookValue.AsCurrency().CPadLeft(13) : "-".CPadLeft(13))}" +
$"{(amort.TotalDays?.ToString(CultureInfo.InvariantCulture) ?? "-").CPadLeft(4)}{amort.Interval.ToString().CPadLeft(20)}");
if (showSchedule && amort.Schedule != null)
{
foreach (var amortItem in amort.Schedule)
{
sb.AppendLine(ListAmortItem(amortItem));
if (amortItem.VoucherID != null)
{
sb.AppendLine(serializer.PresentVoucher(Accountant.SelectVoucher(amortItem.VoucherID)).Wrap());
}
}
}
return(sb.ToString());
}
public TileMap(Stream input, IEntitySerializer serializer)
{
using (BinaryReader reader = new BinaryReader(input, Encoding.UTF8, false)) {
// check for header
if (!reader.ReadBytes(HEADER.Length).SequenceEqual(HEADER))
{
throw new MissingMapIdentifierException( );
}
// load specific mapversion
short version = reader.ReadInt16( );
switch (version)
{
case 1:
Deserialize00001(reader);
break;
case 2:
Deserialize00002(reader);
break;
case 3:
Deserialize00003(reader);
break;
case 4:
Deserialize00004(reader, serializer);
break;
default:
throw new FileLoadException($"map version {version} is not known.");
}
}
}
/// <summary>
/// call back method for asynchronously Executing a Report
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="eventArgs">The <see cref="Intuit.Ipp.Core.AsyncCallCompletedEventArgs"/> instance containing the event data.</param>
private void ExecuteReportAsynCompleted(object sender, AsyncCallCompletedEventArgs eventArgs)
{
ReportCallCompletedEventArgs <Report> reportCallCompletedEventArgs = new ReportCallCompletedEventArgs <Report>();
if (eventArgs.Error == null)
{
try
{
IEntitySerializer responseSerializer = CoreHelper.GetSerializer(this.serviceContext, false);
string response = eventArgs.Result;
if (!response.StartsWith("{\"Report\":"))
{
response = "{\"Report\":" + response + "}";
}
IntuitResponse restResponse = (IntuitResponse)responseSerializer.Deserialize <IntuitResponse>(response);
reportCallCompletedEventArgs.Report = restResponse.AnyIntuitObject as Report;
this.serviceContext.IppConfiguration.Logger.CustomLogger.Log(Diagnostics.TraceLevel.Info, "Finished Executing event Execute ReportAsynCompleted in AsyncService object.");
this.OnExecuteReportAsyncCompleted(this, reportCallCompletedEventArgs);
}
catch (SystemException systemException)
{
IdsException idsException = CreateIdsException(systemException);
this.serviceContext.IppConfiguration.Logger.CustomLogger.Log(TraceLevel.Error, idsException.ToString());
reportCallCompletedEventArgs.Error = idsException;
this.OnExecuteReportAsyncCompleted(this, reportCallCompletedEventArgs);
}
}
else
{
reportCallCompletedEventArgs.Error = eventArgs.Error;
this.OnExecuteReportAsyncCompleted(this, reportCallCompletedEventArgs);
}
}
public ViewQueryResponseFactory(ISerializer serializer, IEntitySerializer entitySerializer)
: base(serializer)
{
Ensure.That(entitySerializer, "entitySerializer").IsNotNull();
EntitySerializer = entitySerializer;
}
/// <summary>
/// GetEntitlements Asynchronous call back method
/// </summary>
/// <param name="sender">Rest handler class</param>
/// <param name="eventArgs">callback event arguments</param>
private void GetEntitlementsAsyncCompleted(object sender, AsyncCallCompletedEventArgs eventArgs)
{
EntitlementCallCompletedEventArgs <Intuit.Ipp.Data.EntitlementsResponse> entitlementCallCompletedEventArgs = new EntitlementCallCompletedEventArgs <EntitlementsResponse>();
if (eventArgs.Error == null)
{
try
{
IEntitySerializer responseSerializer = CoreHelper.GetSerializer(this.serviceContext, false);
EntitlementsResponse restResponse = (EntitlementsResponse)responseSerializer.Deserialize <EntitlementsResponse>(eventArgs.Result);
entitlementCallCompletedEventArgs.EntitlementsResponse = restResponse;
this.serviceContext.IppConfiguration.Logger.CustomLogger.Log(Diagnostics.TraceLevel.Info, "Finished Executing event GetEntitlementsAsync in AyncService object.");
// change Response Serialization Format back to Config value
serviceContext.IppConfiguration.Message.Response.SerializationFormat = orginialSerializationFormat;
this.OnGetEntilementAsyncCompleted(this, entitlementCallCompletedEventArgs);
}
catch (SystemException systemException)
{
IdsException idsException = new IdsException(systemException.Message);
this.serviceContext.IppConfiguration.Logger.CustomLogger.Log(TraceLevel.Error, idsException.ToString());
entitlementCallCompletedEventArgs.Error = idsException;
this.OnGetEntilementAsyncCompleted(this, entitlementCallCompletedEventArgs);
}
}
else
{
entitlementCallCompletedEventArgs.Error = eventArgs.Error;
this.OnGetEntilementAsyncCompleted(this, entitlementCallCompletedEventArgs);
}
}
public SessionFactory(IDatabaseSettings settings, Func <MapConfig, IEntitySerializer, IDataAccessAdapterFactory> adapterFactoryFactoryMethod, IEntitySerializer serializer)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if (adapterFactoryFactoryMethod == null)
{
throw new ArgumentNullException("adapterFactoryFactoryMethod");
}
if (serializer == null)
{
throw new ArgumentNullException("serializer");
}
this.serializer = serializer;
EntitySerializer entitySerializer = serializer as EntitySerializer;
if (entitySerializer != null)
{
entitySerializer.SessionCreator = OpenSession;
}
this.adapterFactoryFactoryMethod = adapterFactoryFactoryMethod;
DbSettings = settings;
connectionManager = new ConnectionManager(DbSettings.Connector, !DbSettings.Connector.AllowMultipleConnections);
}
public BlobRepository(string basePath, string tableName)
{
// create directory
if (!Directory.Exists(basePath))
{
Directory.CreateDirectory(basePath);
}
if (string.IsNullOrEmpty(tableName))
{
tableName = typeof(T).Name;
}
// assign file paths
_dataFilePath = Path.Combine(basePath, String.Format(@"{0}.ndb", tableName));
_dataIndexFilePath = Path.Combine(basePath, String.Format(@"{0}.idx", tableName));
_deletedDataIndexFilePath = Path.Combine(basePath, String.Format(@"{0}_deleted.idx", tableName));
// assign the type of entities that are to be stores in this document store;
_entityName = tableName;
// assign serializer
_serializer = new BSonSerializer();
// call function to initialise document store
Initialize();
}
/// <summary>
/// call back method for asynchronously Executing a Report
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="eventArgs">The <see cref="Intuit.Ipp.Core.AsyncCallCompletedEventArgs"/> instance containing the event data.</param>
private void AddTaxCodeAsyncCompleted(object sender, AsyncCallCompletedEventArgs eventArgs)
{
GlobalTaxServiceCallCompletedEventArgs <Intuit.Ipp.Data.TaxService> taxServiceCallCompletedEventArgs = new GlobalTaxServiceCallCompletedEventArgs <Intuit.Ipp.Data.TaxService>();
if (eventArgs.Error == null)
{
try
{
IEntitySerializer responseSerializer = CoreHelper.GetSerializer(this.serviceContext, false);
IntuitResponse restResponse = (IntuitResponse)responseSerializer.Deserialize <IntuitResponse>(eventArgs.Result);
taxServiceCallCompletedEventArgs.TaxService = restResponse.AnyIntuitObject as Intuit.Ipp.Data.TaxService;
this.serviceContext.IppConfiguration.Logger.CustomLogger.Log(Diagnostics.TraceLevel.Info, "Finished Executing event AddTaxCodeAsyncCompleted in AyncService object.");
this.OnAddTaxCodeAsyncCompleted(this, taxServiceCallCompletedEventArgs);
}
catch (SystemException systemException)
{
IdsException idsException = CreateIdsException(systemException);
this.serviceContext.IppConfiguration.Logger.CustomLogger.Log(TraceLevel.Error, idsException.ToString());
taxServiceCallCompletedEventArgs.Error = idsException;
this.OnAddTaxCodeAsyncCompleted(this, taxServiceCallCompletedEventArgs);
}
}
else
{
taxServiceCallCompletedEventArgs.Error = eventArgs.Error;
this.OnAddTaxCodeAsyncCompleted(this, taxServiceCallCompletedEventArgs);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DistributedCacheService"/> class.
/// </summary>
/// <param name="distributedCache">The distributed cache.</param>
/// <param name="entitySerializer">The entity serializer.</param>
public DistributedCacheService(IDistributedCache distributedCache, IEntitySerializer entitySerializer)
{
this.distributedCache = distributedCache;
this.entitySerializer = entitySerializer;
this.defaultCacheEntryAbsoluteExpriationTime = TimeSpan.FromMinutes(DefaultCacheAbsoluteExpirationMinutes);
this.distributedCacheEntryOptions = new DistributedCacheEntryOptions();
}
/// <summary>
/// Initializes a new instance of the <see cref="RdfSerializer" /> class.
/// </summary>
/// <param name="serialization">The output serialization.</param>
/// <param name="entitySerializer">The entity serializer.</param>
protected RdfSerializer(RdfSerialization serialization, IEntitySerializer entitySerializer)
{
this.serialization = serialization;
this.entitySerializer = entitySerializer;
this.nodeFactory = new NodeFactory();
}
/// <summary>
/// Inits this instance.
/// </summary>
public ISessionFactory Init()
{
if (DbProvider == null)
{
throw new GoliathDataException("no database provider specified");
}
mainMap.MapStatements(DbProvider.Name);
if (LoggerFactory == null)
{
LoggerFactory = x => new NullLogger();
}
if (entitySerializerFactory == null)
{
entitySerializerFactory = new EntitySerializer(this, typeConverterStore);
}
if (dataAccessAdapterFactory == null)
{
dataAccessAdapterFactory = (map, serializer) => new DataAccessAdapterFactory(map, serializer);
}
var dbConnector = DbProvider.GetDatabaseConnector(mainMap.Settings.ConnectionString);
var sessFact = new SessionFactory(this, dataAccessAdapterFactory, entitySerializerFactory);
return(sessFact);
}
/// <summary>
/// Initializes a new instance of the <see cref="NonJsonLdRdfBodyDeserializer"/> class.
/// </summary>
public NonJsonLdRdfBodyDeserializer(
IEntitySerializer serializer,
IRdfConverter converter)
: this(serializer, RdfSerialization.RdfXml, RdfSerialization.NTriples, RdfSerialization.Notation3, RdfSerialization.Turtle)
{
this.converter = converter;
}
/// <summary>
/// Creates a new instance of the <see cref="SqlCigarRepository"/> class.
/// </summary>
/// <param name="client">
/// Required client used to connect to the SQL Server database.
/// </param>
/// <param name="serializer"></param>
public SqlCigarRepository(IDatabaseClient client, IEntitySerializer serializer)
{
_client = client
?? throw new ArgumentNullException(nameof(client));
_serializer = serializer
?? throw new ArgumentNullException(nameof(serializer));
}
public ProxyHydrator(QueryBuilder queryBuilder, Type type, EntityMap entityMap, IEntitySerializer serializer, ISession session)
{
this.type = type;
this.entityMap = entityMap;
this.serializer = serializer;
this.session = session;
this.queryBuilder = queryBuilder;
}
/// <summary>
/// Deserializes an entity from serialization data.
/// </summary>
/// <typeparam name="TEntity">The type of the entity.</typeparam>
/// <typeparam name="TSerializationData">The type of the serialization data, usually a byte array or a string.</typeparam>
/// <param name="serializer">The serializer which to deserialize the entity.</param>
/// <param name="content">The serialized data for the entity.</param>
/// <returns>The object deserialized from the byte array.</returns>
/// <exception cref="ArgumentNullException">Parameter <paramref name="serializer"/> is null.</exception>
public static TEntity Deserialize <TEntity, TSerializationData>(this IEntitySerializer <TEntity, TSerializationData> serializer, TSerializationData content)
{
if (serializer == null)
{
throw new ArgumentNullException(nameof(serializer));
}
return(serializer.Deserialize(content, typeof(TEntity)));
}
/// <summary>
/// Initializes a new instance of the <see cref="Batch"/> class.
/// </summary>
/// <param name="serviceContext">The service context.</param>
/// <param name="restHandler">The rest handler.</param>
internal Batch(ServiceContext serviceContext, IRestHandler restHandler)
{
this.serviceContext = serviceContext;
this.restHandler = restHandler;
this.responseSerializer = CoreHelper.GetSerializer(this.serviceContext, false);
this.batchRequests = new List <BatchItemRequest>();
this.batchResponses = new List <BatchItemResponse>();
this.intuitBatchItemResponses = new List <IntuitBatchResponse>();
}
public Searches(IConnection connection, ISerializer serializer, IEntitySerializer entitySerializer)
: base(connection)
{
Ensure.That(serializer, "serializer").IsNotNull();
Ensure.That(entitySerializer, "entitySerializer").IsNotNull();
SearchIndexHttpRequestFactory = new SearchIndexHttpRequestFactory(Connection);
SearchIndexResponseFactory = new SearchIndexResponseFactory(serializer, entitySerializer);
}
public void AddSerializer(Type type, IEntitySerializer serializer)
{
_serializers[type] = _serializers[type] = serializer;
if (type.IsValueType)
{
var nullableType = typeof(Nullable <>).MakeGenericType(type);
_serializers[nullableType] = new NullableEntitySerializer(serializer);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Batch"/> class.
/// </summary>
/// <param name="serviceContext">The service context.</param>
/// <param name="restHandler">The rest handler.</param>
internal RecurringTransactions(ServiceContext serviceContext, IRestHandler restHandler)
{
this.serviceContext = serviceContext;
this.restHandler = restHandler;
this.responseSerializer = CoreHelper.GetSerializer(this.serviceContext, false);
this.recurringTxnRequests = new List <RecurringTransaction>();
this.batchResponses = new List <BatchItemResponse>();
this.intuitBatchItemResponses = new List <IntuitBatchResponse>();
}
public LazyList(QueryBuilder queryBuilder, EntityMap entityMap, IEntitySerializer serializer, ISession session)
{
this.entityMap = entityMap;
this.serializer = serializer;
this.session = session;
this.queryBuilder = queryBuilder;
IsTracking = true;
list = new List <T>();
}
public Views(IConnection connection, ISerializer serializer, IEntitySerializer entitySerializer)
: base(connection)
{
Ensure.That(serializer, "serializer").IsNotNull();
Ensure.That(entitySerializer, "entitySerializer").IsNotNull();
QueryViewHttpRequestFactory = new QueryViewHttpRequestFactory(Connection);
ViewQueryResponseFactory = new ViewQueryResponseFactory(serializer, entitySerializer);
}
/// <summary>
/// Initializes a new instance of the <see cref="RestHandler"/> class.
/// </summary>
/// <param name="context">The Service Context.</param>
protected RestHandler(ServiceContext context)
: this()
{
this.serviceContext = context;
this.RequestCompressor = CoreHelper.GetCompressor(this.serviceContext, true);
this.ResponseCompressor = CoreHelper.GetCompressor(this.serviceContext, false);
this.RequestSerializer = CoreHelper.GetSerializer(this.serviceContext, true);
this.responseSerializer = CoreHelper.GetSerializer(this.serviceContext, false);
this.RequestLogging = CoreHelper.GetRequestLogging(this.serviceContext);
}
public CategoryController(
IEntitySerializer serializer,
ICategoryFetcher categoryFetcher,
ProductProcessor productProcessor
)
{
_serializer = serializer;
_categoryFetcher = categoryFetcher;
_productProcessor = productProcessor;
}
private NonJsonLdRdfBodyDeserializer(IEntitySerializer serializer, params RdfSerialization[] serializations)
: base(serializer, serializations)
{
this.readers = new Dictionary <RdfSerialization, IRdfReader>
{
{ RdfSerialization.Notation3, new Notation3Parser() },
{ RdfSerialization.RdfXml, new RdfXmlParser() },
{ RdfSerialization.Turtle, new TurtleParser() }
};
}
void SetSerializerFactory(IEntitySerializer serializerFactory)
{
if (serializerFactory == null)
{
throw new ArgumentNullException("serializerFactory");
}
this.serializerFactory = serializerFactory;
isReady = true;
}
/// <summary>
/// Overrides the entity serialize factory.
/// </summary>
/// <param name="entitySerializerFactory">The entity serializer factory.</param>
/// <returns></returns>
public IConfigurationManager RegisterEntitySerializeFactory(IEntitySerializer entitySerializerFactory)
{
if (entitySerializerFactory == null)
{
throw new ArgumentNullException("entitySerializerFactory");
}
this.entitySerializerFactory = entitySerializerFactory;
return(this);
}
public Repository(Context context,
AutoMapper.IMapper mapper,
IConfigurationRoot config,
IEntitySerializer entitySerializer)
{
this.context = Require.IsNotNull(context, nameof(context));
this.mapper = Require.IsNotNull(mapper, nameof(mapper));
this.config = Require.IsNotNull(config, nameof(config));
this.entitySerializer = Require.IsNotNull(entitySerializer, nameof(entitySerializer));
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public void Dispose()
{
EntitySerializer entitySerializer = serializer as EntitySerializer;
if (entitySerializer != null)
{
entitySerializer.SessionCreator = null;
}
serializer = null;
}
public ProductController(
ProductProcessor productProcessor,
IEntitySerializer serializer,
IEntityDeserializer deserializer,
IImageFetcher imageFetcher
)
{
_productProcessor = productProcessor;
_serializer = serializer;
_deserializer = deserializer;
_imageFetcher = imageFetcher;
}
public GetEntityHttpRequestFactory(IConnection connection, IEntitySerializer serializer, IEntityReflector reflector)
: base(connection, serializer, reflector) {}
