Beispiel #1
0
        private OdooRpcRequest CreateReadRequest(OdooSessionInfo sessionInfo, OdooGetParameters getParams, OdooFieldParameters fieldParams)
        {
            List <object> requestArgs = new List <object>(
                new object[]
            {
                sessionInfo.Database,
                sessionInfo.UserId,
                sessionInfo.Password,
                getParams.Model,
                "read",
                new object[]
                {
                    getParams.Ids
                }
            }
                );

            if (fieldParams != null && fieldParams.Count > 0)
            {
                dynamic getOptions = new ExpandoObject();
                getOptions.fields = fieldParams.ToArray();
                requestArgs.Add(getOptions);
            }

            return(new OdooRpcRequest()
            {
                service = "object",
                method = "execute_kw",
                args = requestArgs.ToArray(),
                context = sessionInfo.UserContext
            });
        }
Beispiel #2
0
        private OdooRpcRequest CreateMetadataRequest(OdooSessionInfo sessionInfo, OdooMetadataParameters matadataParams)
        {
            List <object> requestArgs = new List <object>(
                new object[]
            {
                sessionInfo.Database,
                sessionInfo.UserId,
                sessionInfo.Password,
                matadataParams.Model,
                "get_metadata",
                new object[]
                {
                    matadataParams.Ids
                }
            }
                );

            return(new OdooRpcRequest()
            {
                service = "object",
                method = "execute_kw",
                args = requestArgs.ToArray(),
                context = new OdooUserContext()
            });
        }
Beispiel #3
0
        private OdooRpcRequest CreateGetRequest(OdooSessionInfo sessionInfo, OdooGetModelFieldsParameters parameters)
        {
            List <object> requestArgs = new List <object>(
                new object[]
            {
                sessionInfo.Database,
                sessionInfo.UserId,
                sessionInfo.Password,
                parameters.Model,
                "fields_get",
                new object[0]
            }
                );

            dynamic fieldOptions = new ExpandoObject();

            if (parameters.Attributes != null && parameters.Attributes.Count > 0)
            {
                fieldOptions.attributes = parameters.Attributes.ToArray();
            }
            else
            {
                fieldOptions.attributes = new string[] { "string", "help", "type" };
            }
            requestArgs.Add(fieldOptions);

            return(new OdooRpcRequest()
            {
                service = "object",
                method = "execute_kw",
                args = requestArgs.ToArray(),
                context = sessionInfo.UserContext
            });
        }
Beispiel #4
0
        public OdooSessionInfoTests()
        {
            this.ConnectionInfo = new OdooConnectionInfo()
            {
                IsSSL    = false,
                Host     = "test.odoo",
                Port     = 1234,
                Username = "******",
                Password = "******"
            };

            this.SessionInfo = new OdooSessionInfo(ConnectionInfo);
        }
 private OdooRpcRequest CreateLoginRequest(OdooSessionInfo sessionInfo)
 {
     return(new OdooRpcRequest()
     {
         service = "common",
         method = "authenticate",
         args = new object[]
         {
             sessionInfo.Database,
             sessionInfo.Username,
             sessionInfo.Password,
             sessionInfo.UserContext
         }
     });
 }
        public async Task Execute(OdooSessionInfo sessionInfo)
        {
            this.IsLoggedIn = false;
            this.UserId     = null;

            var request = CreateLoginRequest(sessionInfo);
            var result  = await InvokeRpc <object>(sessionInfo, request);

            long uid;

            if (long.TryParse(result.ToString(), out uid))
            {
                this.IsLoggedIn = true;
                this.UserId     = uid;
            }
        }
Beispiel #7
0
        private OdooRpcRequest CreateSearchRequest(OdooSessionInfo sessionInfo, string method, OdooSearchParameters searchParams, OdooFieldParameters fieldParams, OdooPaginationParameters pagParams)
        {
            List <object> requestArgs = new List <object>(
                new object[]
            {
                sessionInfo.Database,
                sessionInfo.UserId,
                sessionInfo.Password,
                searchParams.Model,
                method,
                new object[]
                {
                    searchParams.DomainFilter.ToFilterArray()
                }
            }
                );

            dynamic searchOptions    = new ExpandoObject();
            bool    useSearchOptions = false;

            if (fieldParams != null && fieldParams.Count > 0)
            {
                searchOptions.fields = fieldParams.ToArray();
                useSearchOptions     = true;
            }

            if (pagParams != null && pagParams.IsDefined())
            {
                pagParams.AddToParameters(searchOptions);
                useSearchOptions = true;
            }

            if (useSearchOptions)
            {
                requestArgs.Add(searchOptions);
            }

            return(new OdooRpcRequest()
            {
                service = "object",
                method = "execute_kw",
                args = requestArgs.ToArray(),
                context = sessionInfo.UserContext
            });
        }
 private OdooRpcRequest CreateExecWorkFlowRequest(OdooSessionInfo sessionInfo, string model, string method, object id)
 {
     return(new OdooRpcRequest()
     {
         service = "object",
         method = "exec_workflow",
         args = new object[]
         {
             sessionInfo.Database,
             sessionInfo.UserId,
             sessionInfo.Password,
             model,
             method,
             id
         },
         context = sessionInfo.UserContext
     });
 }
        protected async Task <T> InvokeRpc <T>(OdooSessionInfo sessionInfo, OdooRpcRequest request)
        {
            if (this.IsLoginRequired && !sessionInfo.IsLoggedIn)
            {
                throw new InvalidOperationException("User is not logged in to Odoo");
            }
            else
            {
                var response = await this.RpcClient.InvokeAsync <T>("call", request);

                if (response.Error == null)
                {
                    return(response.Result);
                }
                else
                {
                    throw new RpcCallException(response.Error);
                }
            }
        }
 private OdooRpcRequest CreateCreateDynamicRequest(OdooSessionInfo sessionInfo, string model, string method, object id)
 {
     return(new OdooRpcRequest()
     {
         service = "object",
         method = "execute_kw",
         args = new object[]
         {
             sessionInfo.Database,
             sessionInfo.UserId,
             sessionInfo.Password,
             model,
             method,
             new object[]
             {
                 id
             }
         },
         context = sessionInfo.UserContext
     });
 }
Beispiel #11
0
 private OdooRpcRequest CreateDeleteRequest(OdooSessionInfo sessionInfo, OdooDeleteParameters parameters)
 {
     return(new OdooRpcRequest()
     {
         service = "object",
         method = "execute_kw",
         args = new object[]
         {
             sessionInfo.Database,
             sessionInfo.UserId,
             sessionInfo.Password,
             parameters.Model,
             "unlink",
             new object[]
             {
                 parameters.Ids.ToArray()
             }
         },
         context = sessionInfo.UserContext
     });
 }
Beispiel #12
0
 private OdooRpcRequest CreateLoadRequest(OdooSessionInfo sessionInfo, string model, object data, object header)
 {
     return(new OdooRpcRequest()
     {
         service = "object",
         method = "execute_kw",
         args = new object[]
         {
             sessionInfo.Database,
             sessionInfo.UserId,
             sessionInfo.Password,
             model,
             "load",
             new object[]
             {
                 header,
                 data
             }
         },
         context = sessionInfo.UserContext
     });
 }
Beispiel #13
0
 private OdooRpcRequest CreateUpdateRequest <T>(OdooSessionInfo sessionInfo, OdooUpdateParameters <T> parameters)
 {
     return(new OdooRpcRequest()
     {
         service = "object",
         method = "execute_kw",
         args = new object[]
         {
             sessionInfo.Database,
             sessionInfo.UserId,
             sessionInfo.Password,
             parameters.Model,
             "write",
             new object[]
             {
                 parameters.Ids.ToArray(),
                 parameters.UpdateValues
             }
         },
         context = sessionInfo.UserContext
     });
 }
Beispiel #14
0
 public Task <long> ExecuteCount(OdooSessionInfo sessionInfo, OdooSearchParameters searchParams)
 {
     return(InvokeRpc <long>(sessionInfo, CreateSearchRequest(sessionInfo, "search_count", searchParams, null, null)));
 }
Beispiel #15
0
 public Task Execute(OdooSessionInfo sessionInfo, OdooDeleteParameters parameters)
 {
     return(InvokeRpc <object>(sessionInfo, CreateDeleteRequest(sessionInfo, parameters)));
 }
Beispiel #16
0
 public Task <long[]> Execute <T>(OdooSessionInfo sessionInfo, string model, T data, params string[] header)
 {
     return(InvokeRpc <long[]>(sessionInfo, CreateLoadRequest(sessionInfo, model, data, header)));
 }
Beispiel #17
0
 public Task <Dictionary <string, T> > Execute <T>(OdooSessionInfo sessionInfo, OdooGetModelFieldsParameters parameters)
 {
     return(InvokeRpc <Dictionary <string, T> >(sessionInfo, CreateGetRequest(sessionInfo, parameters)));
 }
Beispiel #18
0
 public Task <IEnumerable <OdooMetadata> > Execute(OdooSessionInfo sessionInfo, OdooMetadataParameters matadataParams)
 {
     return(InvokeRpc <IEnumerable <OdooMetadata> >(sessionInfo, CreateMetadataRequest(sessionInfo, matadataParams)));
 }
 public Task <OdooVersionInfo> Execute(OdooSessionInfo sessionInfo)
 {
     return(InvokeRpc <OdooVersionInfo>(sessionInfo, CreateVersionRequest()));
 }
Beispiel #20
0
 public Task Execute <T>(OdooSessionInfo sessionInfo, OdooUpdateParameters <T> parameters)
 {
     return(InvokeRpc <object>(sessionInfo, CreateUpdateRequest(sessionInfo, parameters)));
 }
 public Task <long> Execute <T>(OdooSessionInfo sessionInfo, string model, T newRecord)
 {
     return(InvokeRpc <long>(sessionInfo, CreateCreateRequest(sessionInfo, model, newRecord)));
 }
Beispiel #22
0
 public Task <T> Execute <T>(OdooSessionInfo sessionInfo, OdooGetParameters getParams, OdooFieldParameters fieldParams)
 {
     return(InvokeRpc <T>(sessionInfo, CreateReadRequest(sessionInfo, getParams, fieldParams)));
 }
 public Task <dynamic> Execute <T>(OdooSessionInfo sessionInfo, string model, string method, T id)
 {
     return(InvokeRpc <dynamic>(sessionInfo, CreateCreateDynamicRequest(sessionInfo, model, method, id)));
 }
Beispiel #24
0
 public Task <T> Execute <T>(OdooSessionInfo sessionInfo, OdooSearchParameters searchParams, OdooFieldParameters fieldParams, OdooPaginationParameters pagParams)
 {
     return(InvokeRpc <T>(sessionInfo, CreateSearchRequest(sessionInfo, "search_read", searchParams, fieldParams, pagParams)));
 }
 public Task <long> Execute <T>(OdooSessionInfo sessionInfo, string model, string method, T id)
 {
     return(InvokeRpc <long>(sessionInfo, CreateExecWorkFlowRequest(sessionInfo, model, method, id)));
 }