brick

csst_dfs_api_cluster/facility/__init__.py

-from .calmerge import CalMergeApi
+from .brick import BrickApi
 from .detector import DetectorApi
-from .level0 import Level0DataApi
-from .level0prc import Level0PrcApi
-from .level1prc import Level1PrcApi
+from .level2producer import Level1PrcApi
 from .observation import ObservationApi
\ No newline at end of file

csst_dfs_api_cluster/facility/brick.py

+import grpc
+
+from csst_dfs_commons.models import Result
+from csst_dfs_commons.models.common import from_proto_model_list
+from csst_dfs_commons.models.facility import Brick, FindObsStatus, BrickLevel1
+
+from csst_dfs_proto.facility.brick import brick_pb2, brick_pb2_grpc
+
+from ..common.service import ServiceProxy
+from ..common.utils import *
+from ..common.constants import UPLOAD_CHUNK_SIZE
+
+class BrickApi(object):
+    """
+    Brick Operation Class
+    """    
+    def __init__(self):
+        self.stub = brick_pb2_grpc.BrickSrvStub(ServiceProxy().channel())
+
+    def find(self, **kwargs):
+        ''' find brick records
+
+        :param kwargs:
+            limit: limits returns the number of records,default 0:no-limit
+
+        :returns: csst_dfs_common.models.Result
+        '''
+        try:
+            resp, _ =  self.stub.Find.with_call(brick_pb2.FindBrickReq(
+                limit = get_parameter(kwargs, "limit", 0),
+                other_conditions = {"test":"cnlab.test"}
+            ),metadata = get_auth_headers())
+
+            if resp.success:
+                return Result.ok_data(data = from_proto_model_list(Brick, resp.records)).append("totalCount", resp.totalCount)
+            else:
+                return Result.error(message = str(resp.error.detail))
+
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def get(self, **kwargs):
+        '''  fetch a record from database
+
+        :param kwargs:
+            id : [int]
+
+        :returns: csst_dfs_common.models.Result
+        '''
+        try:
+            brick_id = get_parameter(kwargs, "id", -1)
+            resp, _ =  self.stub.Get.with_call(brick_pb2.GetBrickReq(
+                id = brick_id
+            ),metadata = get_auth_headers())
+
+            if resp.brick is None or resp.brick.id == -1:
+                return Result.error(message=f"{brick_id} not found")  
+
+            return Result.ok_data(data=Brick().from_proto_model(resp.record))
+           
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))        
+
+    def write(self, **kwargs):
+        ''' insert a brickal record into database
+
+        :param kwargs: Parameter dictionary, key items support:
+            ra = [float],
+            dec = [float],
+            boundingbox = [str]
+        
+        :returns: csst_dfs_common.models.Result
+        '''  
+        rec = brick_pb2.Brick(
+            id = get_parameter(kwargs, "id", 0),
+            ra = get_parameter(kwargs, "ra", 0.0),
+            dec = get_parameter(kwargs, "dec", 0.0),
+            boundingbox = get_parameter(kwargs, "boundingbox", "")
+        )
+        req = brick_pb2.WriteBrickReq(record = rec)
+        try:
+            resp,_ = self.stub.Write.with_call(req,metadata = get_auth_headers())
+            if resp.success:
+                return Result.ok_data(data=Brick().from_proto_model(resp.record))
+            else:
+                return Result.error(message = str(resp.error.detail))
+    
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def find_obs_status(self, **kwargs):
+        ''' find observation status of bricks
+
+        :param kwargs:
+            brick_id = [int],
+            band = [string]
+
+        :returns: csst_dfs_common.models.Result
+        '''
+        try:
+            resp, _ =  self.stub.FindObsStatus.with_call(brick_pb2.FindObsStatusReq(
+                brick_id = get_parameter(kwargs, "brick_id", -1),
+                band = get_parameter(kwargs, "band", "")
+            ),metadata = get_auth_headers())
+
+            if resp.success:
+                return Result.ok_data(data = from_proto_model_list(FindObsStatus, resp.records)).append("totalCount", resp.totalCount)
+            else:
+                return Result.error(message = str(resp.error.detail))
+
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def find_level1_data(self, **kwargs):
+        ''' find level1 data
+
+        :param kwargs: Parameter dictionary, support:
+            brick_id = [int]\n
+            level1_id = [int]\n
+            module = [str]
+
+        :returns: csst_dfs_common.models.Result
+        '''
+        try:
+            resp, _ =  self.stub.FindLevel1.with_call(brick_pb2.FindLevel1Req(
+                brick_id = get_parameter(kwargs, "brick_id", -1),
+                level1_id = get_parameter(kwargs, "level1_id", 0),
+                module = get_parameter(kwargs, "limit", "")
+            ),metadata = get_auth_headers())
+
+            if resp.success:
+                return Result.ok_data(data = from_proto_model_list(BrickLevel1, resp.records)).append("totalCount", resp.totalCount)
+            else:
+                return Result.error(message = str(resp.error.detail))
+
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))

csst_dfs_api_cluster/facility/level2producer.py

+import grpc
+
+from csst_dfs_commons.models import Result
+from csst_dfs_commons.models.common import from_proto_model_list
+from csst_dfs_commons.models.facility import Level2Producer, Level2Job, Level2ProducerRuning
+
+from csst_dfs_proto.facility.level2producer import level2producer_pb2, level2producer_pb2_grpc
+
+from ..common.service import ServiceProxy
+from ..common.utils import *
+from ..common.constants import UPLOAD_CHUNK_SIZE
+
+class Level2ProducerApi(object):
+    """
+    Level2Producer Operation Class
+    """    
+    def __init__(self):
+        self.stub = level2producer_pb2_grpc.Level2ProducerSrvStub(ServiceProxy().channel())
+
+    def register(self, **kwargs):
+        ''' register a Level2Producer data record into database
+ 
+        :param kwargs: Parameter dictionary, key items support:
+            name = [str]\n
+            gitlink = [str]\n
+            paramfiles = [str]\n
+            priority = [int]\n
+            pre_producers = list[int]
+        
+        :returns: csst_dfs_common.models.Result
+        '''  
+        rec = level2producer_pb2.Level2ProducerRecord(
+            id = get_parameter(kwargs, "id", 0),
+            name = get_parameter(kwargs, "name", ""),
+            gitlink = get_parameter(kwargs, "gitlink"),
+            paramfiles = get_parameter(kwargs, "paramfiles"),
+            priority = get_parameter(kwargs, "priority", 0),
+            pre_producers = get_parameter(kwargs, "pre_producers",[]),
+        )
+        req = level2producer_pb2.RegisterReq(record = rec)
+        try:
+            resp,_ = self.stub.Register.with_call(req, metadata = get_auth_headers())
+            if resp.success:
+                return Result.ok_data(data=Level2Producer().from_proto_model(resp.record))
+            else:
+                return Result.error(message = str(resp.error.detail))
+    
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def find(self, **kwargs):
+        ''' retrieve Level2Producer records from database
+
+        :param kwargs: Parameter dictionary, key items support:
+            key: [str]
+            limit: limits returns the number of records,default 0:no-limit
+        
+        :returns: csst_dfs_common.models.Result
+        '''
+        try:
+            resp, _ =  self.stub.Find.with_call(level2producer_pb2.FindReq(
+                key = get_parameter(kwargs, "key", "")
+            ),metadata = get_auth_headers())
+
+            if resp.success:
+                return Result.ok_data(data = from_proto_model_list(Level2Producer, resp.records)).append("totalCount", resp.totalCount)
+            else:
+                return Result.error(message = str(resp.error.detail))
+
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def get(self, **kwargs):
+        '''  fetch a record from database
+
+        parameter kwargs:
+            id : [int]
+
+        return csst_dfs_common.models.Result
+        '''
+        try:
+            p_id = get_parameter(kwargs, "id", 0)
+            resp, _ =  self.stub.Get.with_call(level2producer_pb2.GetReq(
+                id = p_id
+            ),metadata = get_auth_headers())
+
+            if resp.record is None or resp.record.id == 0:
+                return Result.error(message=f"{p_id} not found")  
+
+            return Result.ok_data(data=Level2Producer().from_proto_model(resp.record))
+           
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))        
+
+    def find_nexts(self, **kwargs):
+        ''' retrieve Level2Producer records from database
+
+        :param kwargs: Parameter dictionary, key items support:
+            id : [int]
+        
+        :returns: csst_dfs_common.models.Result
+        '''
+        try:
+
+            resp, _ =  self.stub.FindNexts.with_call(level2producer_pb2.FindNextsReq(
+                id = get_parameter(kwargs, "id")
+            ),metadata = get_auth_headers())
+
+            if resp.success:
+                return Result.ok_data(data = from_proto_model_list(Level2Producer, resp.records)).append("totalCount", resp.totalCount)
+            else:
+                return Result.error(message = str(resp.error.detail))
+
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def find_start(self, **kwargs):
+        ''' retrieve Level2Producer records from database
+
+        :param kwargs: Parameter dictionary, key items support:
+            key : [str]
+        
+        :returns: csst_dfs_common.models.Result
+        '''
+        try:
+
+            resp, _ =  self.stub.FindStart.with_call(level2producer_pb2.FindStartReq(
+                key = get_parameter(kwargs, "key", "")
+            ),metadata = get_auth_headers())
+
+            if resp.success:
+                return Result.ok_data(data = from_proto_model_list(Level2Producer, resp.records)).append("totalCount", resp.totalCount)
+            else:
+                return Result.error(message = str(resp.error.detail))
+
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))            
+
+    def update(self, **kwargs):
+        ''' update a Level2Producer
+        
+        :param kwargs: Parameter dictionary, key items support:
+            id : [int]\n
+            name = [str]\n
+            gitlink = [str]\n
+            paramfiles = [str]\n
+            priority = [int]\n
+            pre_producers = list[int]
+        
+        :returns: csst_dfs_common.models.Result            
+        '''   
+        try:
+            resp,_ = self.stub.Update.with_call(
+                level2producer_pb2.UpdateReq(
+                    id = get_parameter(kwargs, "id", 0),
+                    name = get_parameter(kwargs, "name", ""),
+                    gitlink = get_parameter(kwargs, "gitlink", ""),
+                    paramfiles = get_parameter(kwargs, "paramfiles", ""),
+                    priority = get_parameter(kwargs, "priority", 0),
+                    pre_producers = get_parameter(kwargs, "pre_producers",[])
+                ),
+                metadata = get_auth_headers()
+            )
+            if resp.success:
+                return Result.ok_data()
+            else:
+                return Result.error(message = str(resp.error.detail))
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def delete(self, **kwargs):
+        ''' delete a Level2Producer data
+ 
+        :param kwargs: Parameter dictionary, key items support:
+            id = [int]
+        
+        :returns: csst_dfs_common.models.Result
+        '''     
+        try:
+            resp,_ = self.stub.Delete.with_call(
+                level2producer_pb2.DeleteReq(
+                    id = get_parameter(kwargs, "id", 0)),
+                metadata = get_auth_headers()
+            )
+            if resp.success:
+                return Result.ok_data()
+            else:
+                return Result.error(message = str(resp.error.detail))
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def new_job(self, **kwargs):
+        ''' new a Level2Producer Job
+ 
+        :param kwargs: Parameter dictionary, key items support:
+            dag = [str]
+        
+        :returns: csst_dfs_common.models.Result
+        '''  
+        rec = level2producer_pb2.Level2JobRecord(
+            id = 0,
+            dag = get_parameter(kwargs, "dag", "")
+        )
+        req = level2producer_pb2.NewJobReq(record = rec)
+        try:
+            resp,_ = self.stub.NewJob.with_call(req, metadata = get_auth_headers())
+            if resp.success:
+                return Result.ok_data(data=Level2Job().from_proto_model(resp.record))
+            else:
+                return Result.error(message = str(resp.error.detail))
+    
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def get_job(self, **kwargs):
+        '''  fetch a record from database
+
+        parameter kwargs:
+            id : [int]
+
+        return csst_dfs_common.models.Result
+        '''
+        try:
+            p_id = get_parameter(kwargs, "id", 0)
+            resp, _ =  self.stub.GetJob.with_call(level2producer_pb2.GetJobReq(
+                id = p_id
+            ),metadata = get_auth_headers())
+
+            if resp.record is None or resp.record.id == 0:
+                return Result.error(message=f"{p_id} not found")  
+
+            return Result.ok_data(data=Level2Job().from_proto_model(resp.record))
+           
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))  
+
+    def update_job(self, **kwargs):
+        ''' update a Level2Producer Job
+ 
+        :param kwargs: Parameter dictionary, key items support:
+            id = [int]
+            dag = [str]
+            status = [int]
+        
+        :returns: csst_dfs_common.models.Result
+        '''    
+        rec = level2producer_pb2.Level2JobRecord(
+            id = get_parameter(kwargs, "id", 0), 
+            dag = get_parameter(kwargs, "dag", ""),
+            status = get_parameter(kwargs, "status", -1)
+        )
+        req = level2producer_pb2.UpdateJobReq(record = rec)
+        try:
+            resp,_ = self.stub.UpdateJob.with_call(req, metadata = get_auth_headers())
+            if resp.success:
+                return Result.ok_data()
+            else:
+                return Result.error(message = str(resp.error.detail))
+    
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))   
+
+    def new_running(self, **kwargs):
+        ''' insert a Level2ProducerRuningRecord data
+ 
+        :param kwargs: Parameter dictionary, key items support:
+            job_id = [int]\n
+            producer_id = [int]\n
+            brick_id = [int]\n
+            start_time = [str]\n
+            end_time = [str]\n
+            prc_status = [int]\n
+            prc_result = [str]
+        
+        :returns: csst_dfs_common.models.Result
+        ''' 
+        rec = level2producer_pb2.Level2ProducerRuningRecord(
+            id = 0,
+            job_id = get_parameter(kwargs, "job_id", 0),
+            producer_id = get_parameter(kwargs, "producer_id", 0),
+            brick_id = get_parameter(kwargs, "brick_id", 0),
+            start_time = get_parameter(kwargs, "start_time", ""),
+            prc_status = get_parameter(kwargs, "prc_status", 0),
+            prc_result = get_parameter(kwargs, "prc_result", "")
+        )
+        req = level2producer_pb2.WriteRunningReq(record = rec)
+        try:
+            resp,_ = self.stub.WriteRunning.with_call(req, metadata = get_auth_headers())
+            if resp.success:
+                return Result.ok_data(data=Level2ProducerRuning().from_proto_model(resp.record))
+            else:
+                return Result.error(message = str(resp.error.detail))
+    
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def get_running(self, **kwargs):
+        '''  fetch a record from database
+
+        parameter kwargs:
+            id : [int]
+
+        return csst_dfs_common.models.Result
+        '''
+        try:
+            p_id = get_parameter(kwargs, "id", 0)
+            resp, _ =  self.stub.GetRunning.with_call(level2producer_pb2.GetRunningReq(
+                id = p_id
+            ),metadata = get_auth_headers())
+
+            if resp.record is None or resp.record.id == 0:
+                return Result.error(message=f"{p_id} not found")  
+
+            return Result.ok_data(data=Level2ProducerRuning().from_proto_model(resp.record))
+           
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))  
+
+    def udpate_running(self, **kwargs):
+        ''' udpate a Level2ProducerRuningRecord data
+ 
+        :param kwargs: Parameter dictionary, key items support:
+            id = [int]\n
+            job_id = [int]\n
+            producer_id = [int]\n
+            brick_id = [int]\n
+            start_time = [str]\n
+            end_time = [str]\n
+            prc_status = [int]\n
+            prc_result = [str]
+        
+        :returns: csst_dfs_common.models.Result
+        ''' 
+        rec = level2producer_pb2.Level2ProducerRuningRecord(
+            id = get_parameter(kwargs, "id", 0),
+            job_id = get_parameter(kwargs, "job_id", 0),
+            producer_id = get_parameter(kwargs, "producer_id", 0),
+            brick_id = get_parameter(kwargs, "brick_id", 0),
+            start_time = get_parameter(kwargs, "start_time", ""),
+            end_time = get_parameter(kwargs, "end_time", ""),
+            prc_status = get_parameter(kwargs, "prc_status", 0),
+            prc_result = get_parameter(kwargs, "prc_result", "")
+        )
+        req = level2producer_pb2.UpdateRunningReq(record = rec)
+        try:
+            resp,_ = self.stub.UpdateRunning.with_call(req, metadata = get_auth_headers())
+            if resp.success:
+                return Result.ok_data()
+            else:
+                return Result.error(message = str(resp.error.detail))
+    
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def find_running(self, **kwargs):
+        ''' udpate a Level2ProducerRuningRecord data
+ 
+        :param kwargs: Parameter dictionary, key items support:
+            job_id = [int]\n
+            producer_id = [int]\n
+            brick_id = [int]\n
+            create_time = (start, end),\n
+            prc_status = [int]\n
+            prc_result = [str]
+        
+        :returns: csst_dfs_common.models.Result
+        ''' 
+        req = level2producer_pb2.FindRunningReq(
+            job_id = get_parameter(kwargs, "job_id", 0),
+            producer_id = get_parameter(kwargs, "producer_id", 0),
+            brick_id = get_parameter(kwargs, "brick_id", 0),
+            prc_status = get_parameter(kwargs, "prc_status", 0),
+            start_time = get_parameter(kwargs, "create_time", [None, None])[0],
+            end_time = get_parameter(kwargs, "create_time", [None, None])[1],
+            limit = get_parameter(kwargs, "limit", 0)           
+        )
+        try:
+            resp,_ = self.stub.FindRunning.with_call(req, metadata = get_auth_headers())
+            if resp.success:
+                return Result.ok_data(data = from_proto_model_list(Level2ProducerRuning, resp.records)).append("totalCount", resp.totalCount)
+            else:
+                return Result.error(message = str(resp.error.detail))
+    
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))            
\ No newline at end of file

csst_dfs_api_cluster/ifs/__init__.py

-from .level1 import Level1DataApi
+from .calmerge import CalMergeApi
\ No newline at end of file
+from .level0 import Level0DataApi
+from .level0prc import Level0PrcApi
+from .level1 import Level1DataApi
+from .level1prc import Level1PrcApi

csst_dfs_api_cluster/ifs/calmerge.py

+import grpc
+
+from csst_dfs_commons.models import Result
+from csst_dfs_commons.models.common import from_proto_model_list
+from csst_dfs_commons.models.ifs import CalMergeRecord
+
+from csst_dfs_proto.ifs.calmerge import calmerge_pb2, calmerge_pb2_grpc
+
+from ..common.service import ServiceProxy
+from ..common.utils import *
+
+class CalMergeApi(object):
+    def __init__(self):
+        self.stub = calmerge_pb2_grpc.CalMergeSrvStub(ServiceProxy().channel())
+
+    def get_latest_by_l0(self, **kwargs):
+        ''' retrieve calibration merge records from database by level0 data
+
+        parameter kwargs:
+            level0_id: [str]
+            ref_type: [str]
+
+        return: csst_dfs_common.models.Result
+        '''
+        try:
+            resp, _ =  self.stub.GetLatestByL0.with_call(calmerge_pb2.GetLatestByL0Req(
+                level0_id = get_parameter(kwargs, "level0_id"),
+                ref_type = get_parameter(kwargs, "ref_type")),
+            metadata = get_auth_headers())
+
+            if resp.record.id == 0:
+                return Result.error(message=f"not found")  
+
+            return Result.ok_data(data=CalMergeRecord().from_proto_model(resp.record))
+
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def find(self, **kwargs):
+        ''' retrieve calibration merge records from database
+
+        parameter kwargs:
+            detector_no: [str]
+            ref_type: [str]
+            obs_time: (start,end)
+            qc1_status : [int]
+            prc_status : [int]
+            file_name: [str]
+            limit: limits returns the number of records,default 0:no-limit
+
+        return: csst_dfs_common.models.Result
+        '''
+        try:
+            resp, _ =  self.stub.Find.with_call(calmerge_pb2.FindCalMergeReq(
+                detector_no = get_parameter(kwargs, "detector_no"),
+                ref_type = get_parameter(kwargs, "ref_type"),
+                exp_time_start = get_parameter(kwargs, "obs_time", [None, None])[0],
+                exp_time_end = get_parameter(kwargs, "obs_time", [None, None])[1],                
+                qc1_status = get_parameter(kwargs, "qc1_status"),
+                prc_status = get_parameter(kwargs, "prc_status"),
+                file_name = get_parameter(kwargs, "file_name"),
+                limit = get_parameter(kwargs, "limit"),
+                other_conditions = {"test":"cnlab.test"}
+            ),metadata = get_auth_headers())
+
+            if resp.success:
+                return Result.ok_data(data=from_proto_model_list(CalMergeRecord,resp.records)).append("totalCount", resp.totalCount)
+            else:
+                return Result.error(message = str(resp.error.detail))
+
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def get(self, **kwargs):
+        '''  fetch a record from database
+
+        :param kwargs: Parameter dictionary, key items support:
+            id : [int]
+        
+        :returns: csst_dfs_common.models.Result
+        '''
+        try:
+            id = get_parameter(kwargs, "id", 0)
+            cal_id = get_parameter(kwargs, "cal_id", "")
+            resp, _ =  self.stub.Get.with_call(calmerge_pb2.GetCalMergeReq(
+                id = id,
+                cal_id = cal_id
+            ),metadata = get_auth_headers())
+
+            if resp.record.id == 0:
+                return Result.error(message=f"not found")  
+
+            return Result.ok_data(data=CalMergeRecord().from_proto_model(resp.record))
+           
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))   
+
+    def update_qc1_status(self, **kwargs):
+        ''' update the status of reduction
+
+        parameter kwargs:
+            id : [int],
+            cal_id = cal_id,
+            status : [int]
+
+        return csst_dfs_common.models.Result
+        '''
+        id = get_parameter(kwargs, "id", 0)
+        cal_id = get_parameter(kwargs, "cal_id", "")
+        status = get_parameter(kwargs, "status")
+
+        try:
+            resp,_ = self.stub.UpdateQc1Status.with_call(
+                calmerge_pb2.UpdateQc1StatusReq(
+                    id = id, 
+                    cal_id = cal_id,
+                    status=status),
+                metadata = get_auth_headers()
+            )
+            if resp.success:
+                return Result.ok_data()
+            else:
+                return Result.error(message = str(resp.error.detail))
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def update_proc_status(self, **kwargs):
+        ''' update the status of reduction
+
+        parameter kwargs:
+            id : [int],
+            cal_id: [str],
+            status : [int]
+
+        return csst_dfs_common.models.Result
+        '''
+        id = get_parameter(kwargs, "id", 0)
+        cal_id = get_parameter(kwargs, "cal_id", "")
+        status = get_parameter(kwargs, "status")
+
+        try:
+            resp,_ = self.stub.UpdateProcStatus.with_call(
+                calmerge_pb2.UpdateProcStatusReq(
+                    id = id,
+                    cal_id = cal_id,
+                    status=status),
+                metadata = get_auth_headers()
+            )
+            if resp.success:
+                return Result.ok_data()
+            else:
+                return Result.error(message = str(resp.error.detail))
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def write(self, **kwargs):
+        ''' insert a calibration merge record into database
+ 
+        parameter kwargs:
+            cal_id : [str],
+            detector_no : [str]
+            ref_type : [str]
+            obs_time : [str]
+            exp_time : [float]
+            prc_status : [int]
+            prc_time : [str]
+            filename : [str]
+            file_path : [str]
+            level0_ids : [list]
+        return csst_dfs_common.models.Result
+        '''   
+
+        rec = calmerge_pb2.CalMergeRecord(
+            id = 0,
+            cal_id = get_parameter(kwargs, "cal_id"),
+            detector_no = get_parameter(kwargs, "detector_no"),
+            ref_type = get_parameter(kwargs, "ref_type"),
+            obs_time = get_parameter(kwargs, "obs_time"),
+            exp_time = get_parameter(kwargs, "exp_time"),
+            filename = get_parameter(kwargs, "filename"),
+            file_path = get_parameter(kwargs, "file_path"),
+            prc_status = get_parameter(kwargs, "prc_status",-1),
+            prc_time = get_parameter(kwargs, "prc_time"),
+            level0_ids = get_parameter(kwargs, "level0_ids", [])
+        )
+        req = calmerge_pb2.WriteCalMergeReq(record = rec)
+        try:
+            resp,_ = self.stub.Write.with_call(req,metadata = get_auth_headers())
+            if resp.success:
+                return Result.ok_data(data=CalMergeRecord().from_proto_model(resp.record))
+            else:
+                return Result.error(message = str(resp.error.detail))
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+

csst_dfs_api_cluster/facility/level0.py → csst_dfs_api_cluster/ifs/level0.py

@@ -2,9 +2,9 @@ import grpc
 
 from csst_dfs_commons.models import Result
 from csst_dfs_commons.models.common import from_proto_model_list
-from csst_dfs_commons.models.facility import Level0Record
+from csst_dfs_commons.models.ifs import Level0Record
 
-from csst_dfs_proto.facility.level0 import level0_pb2, level0_pb2_grpc
+from csst_dfs_proto.ifs.level0 import level0_pb2, level0_pb2_grpc
 
 from ..common.service import ServiceProxy
 from ..common.utils import *

csst_dfs_api_cluster/facility/level0prc.py → csst_dfs_api_cluster/ifs/level0prc.py

@@ -2,9 +2,9 @@ import grpc
 
 from csst_dfs_commons.models import Result
 from csst_dfs_commons.models.common import from_proto_model_list
-from csst_dfs_commons.models.facility import Level0PrcRecord
+from csst_dfs_commons.models.ifs import Level0PrcRecord
 
-from csst_dfs_proto.facility.level0prc import level0prc_pb2, level0prc_pb2_grpc
+from csst_dfs_proto.ifs.level0prc import level0prc_pb2, level0prc_pb2_grpc
 
 from ..common.service import ServiceProxy
 from ..common.utils import *

csst_dfs_api_cluster/facility/level1prc.py → csst_dfs_api_cluster/ifs/level1prc.py

@@ -2,9 +2,9 @@ import grpc
 
 from csst_dfs_commons.models import Result
 from csst_dfs_commons.models.common import from_proto_model_list
-from csst_dfs_commons.models.facility import Level1PrcRecord
+from csst_dfs_commons.models.ifs import Level1PrcRecord
 
-from csst_dfs_proto.facility.level1prc import level1prc_pb2, level1prc_pb2_grpc
+from csst_dfs_proto.ifs.level1prc import level1prc_pb2, level1prc_pb2_grpc
 
 from ..common.service import ServiceProxy
 from ..common.utils import *

csst_dfs_api_cluster/msc/__init__.py

+from .calmerge import CalMergeApi
+from .level0 import Level0DataApi
+from .level0prc import Level0PrcApi
 from .level1 import Level1DataApi
+from .level1prc import Level1PrcApi
 from .level2catalog import Level2CatalogApi
\ No newline at end of file

csst_dfs_api_cluster/facility/calmerge.py → csst_dfs_api_cluster/msc/calmerge.py

@@ -2,9 +2,9 @@ import grpc
 
 from csst_dfs_commons.models import Result
 from csst_dfs_commons.models.common import from_proto_model_list
-from csst_dfs_commons.models.facility import CalMergeRecord
+from csst_dfs_commons.models.msc import CalMergeRecord
 
-from csst_dfs_proto.facility.calmerge import calmerge_pb2, calmerge_pb2_grpc
+from csst_dfs_proto.msc.calmerge import calmerge_pb2, calmerge_pb2_grpc
 
 from ..common.service import ServiceProxy
 from ..common.utils import *

csst_dfs_api_cluster/msc/level0.py

+import grpc
+
+from csst_dfs_commons.models import Result
+from csst_dfs_commons.models.common import from_proto_model_list
+from csst_dfs_commons.models.msc import Level0Record
+
+from csst_dfs_proto.msc.level0 import level0_pb2, level0_pb2_grpc
+
+from ..common.service import ServiceProxy
+from ..common.utils import *
+
+class Level0DataApi(object):
+    def __init__(self):
+        self.stub = level0_pb2_grpc.Level0SrvStub(ServiceProxy().channel())
+
+    def find(self, **kwargs):
+        ''' retrieve level0 records from database
+
+        parameter kwargs:
+            obs_id: [str]
+            detector_no: [str]
+            obs_type: [str]
+            obs_time : (start, end),
+            qc0_status : [int],
+            prc_status : [int],
+            file_name: [str]
+            limit: limits returns the number of records,default 0:no-limit
+
+        return: csst_dfs_common.models.Result
+        '''
+        try:
+            resp, _ =  self.stub.Find.with_call(level0_pb2.FindLevel0DataReq(
+                obs_id = get_parameter(kwargs, "obs_id"),
+                detector_no = get_parameter(kwargs, "detector_no"),
+                obs_type = get_parameter(kwargs, "obs_type"),
+                exp_time_start = get_parameter(kwargs, "obs_time", [None, None])[0],
+                exp_time_end = get_parameter(kwargs, "obs_time", [None, None])[1],
+                qc0_status = get_parameter(kwargs, "qc0_status"),
+                prc_status = get_parameter(kwargs, "prc_status"),
+                file_name = get_parameter(kwargs, "file_name"),
+                limit = get_parameter(kwargs, "limit", 0),
+                other_conditions = {"test":"cnlab.test"}
+            ),metadata = get_auth_headers())
+
+            if resp.success:
+                return Result.ok_data(data=from_proto_model_list(Level0Record, resp.records)).append("totalCount", resp.totalCount)
+            else:
+                return Result.error(message = str(resp.error.detail))
+
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def get(self, **kwargs):
+        '''  fetch a record from database
+
+        parameter kwargs:
+            id : [int],
+            level0_id: [str]
+
+        return csst_dfs_common.models.Result
+        '''
+        try:
+            id = get_parameter(kwargs, "id")
+            level0_id = get_parameter(kwargs, "level0_id")
+            resp, _ =  self.stub.Get.with_call(level0_pb2.GetLevel0DataReq(
+                id = id,
+                level0_id = level0_id
+            ),metadata = get_auth_headers())
+
+            if resp.record is None or resp.record.id == 0:
+                return Result.error(message=f"not found")  
+
+            return Result.ok_data(data = Level0Record().from_proto_model(resp.record))
+           
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))   
+
+    def update_proc_status(self, **kwargs):
+        ''' update the status of reduction
+
+        parameter kwargs:
+            id : [int],
+            level0_id: [str],
+            status : [int]
+
+        return csst_dfs_common.models.Result
+        '''
+        id = get_parameter(kwargs, "id")
+        level0_id = get_parameter(kwargs, "level0_id")
+        status = get_parameter(kwargs, "status")
+        try:
+            resp,_ = self.stub.UpdateProcStatus.with_call(
+                level0_pb2.UpdateProcStatusReq(
+                    id=id,
+                    level0_id = level0_id,
+                    status=status),
+                metadata = get_auth_headers()
+            )
+            if resp.success:
+                return Result.ok_data()
+            else:
+                return Result.error(message = str(resp.error.detail))
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def update_qc0_status(self, **kwargs):
+        ''' update the status of QC0
+        
+        parameter kwargs:
+            id : [int],
+            level0_id: [str],
+            status : [int]
+        '''        
+        id = get_parameter(kwargs, "id")
+        level0_id = get_parameter(kwargs, "level0_id")
+        status = get_parameter(kwargs, "status")
+        try:
+            resp,_ = self.stub.UpdateQc0Status.with_call(
+                level0_pb2.UpdateQc0StatusReq( 
+                    id=id,
+                    level0_id = level0_id,
+                    status=status),
+                metadata = get_auth_headers()
+            )
+            if resp.success:
+                return Result.ok_data()
+            else:
+                return Result.error(message = str(resp.error.detail))
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def write(self, **kwargs):
+        ''' insert a level0 data record into database
+ 
+        parameter kwargs:
+            obs_id = [str]
+            detector_no = [str]
+            obs_type = [str]        
+            obs_time = [str]
+            exp_time = [int]
+            detector_status_id = [int]
+            filename = [str]
+            file_path = [str]
+        return: csst_dfs_common.models.Result
+        '''          
+        rec = level0_pb2.Level0Record(
+            obs_id = get_parameter(kwargs, "obs_id"),
+            detector_no = get_parameter(kwargs, "detector_no"),
+            obs_type = get_parameter(kwargs, "obs_type"),
+            obs_time = get_parameter(kwargs, "obs_time"),
+            exp_time = get_parameter(kwargs, "exp_time"),
+            detector_status_id = get_parameter(kwargs, "detector_status_id"),
+            filename = get_parameter(kwargs, "filename"),
+            file_path = get_parameter(kwargs, "file_path")
+        )
+        req = level0_pb2.WriteLevel0DataReq(record = rec)
+        try:
+            resp,_ = self.stub.Write.with_call(req,metadata = get_auth_headers())
+            if resp.success:
+                return Result.ok_data(data = Level0Record().from_proto_model(resp.record))
+            else:
+                return Result.error(message = str(resp.error.detail))
+    
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+

csst_dfs_api_cluster/msc/level0prc.py

+import grpc
+
+from csst_dfs_commons.models import Result
+from csst_dfs_commons.models.common import from_proto_model_list
+from csst_dfs_commons.models.msc import Level0PrcRecord
+
+from csst_dfs_proto.msc.level0prc import level0prc_pb2, level0prc_pb2_grpc
+
+from ..common.service import ServiceProxy
+from ..common.utils import *
+
+class Level0PrcApi(object):
+    def __init__(self):
+        self.stub = level0prc_pb2_grpc.Level0PrcSrvStub(ServiceProxy().channel())
+
+    def find(self, **kwargs):
+        ''' retrieve level0 procedure records from database
+
+        parameter kwargs:
+            level0_id: [str]
+            pipeline_id: [str]
+            prc_module: [str]
+            prc_status : [int]
+
+        return: csst_dfs_common.models.Result
+        '''
+        try:
+            resp, _ =  self.stub.Find.with_call(level0prc_pb2.FindLevel0PrcReq(
+                level0_id = get_parameter(kwargs, "level0_id"),
+                pipeline_id = get_parameter(kwargs, "pipeline_id"),
+                prc_module = get_parameter(kwargs, "prc_module"),
+                prc_status = get_parameter(kwargs, "prc_status"),
+                other_conditions = {"test":"cnlab.test"}
+            ),metadata = get_auth_headers())
+
+            if resp.success:
+                return Result.ok_data(data = from_proto_model_list(Level0PrcRecord, resp.records)).append("totalCount", resp.totalCount)
+            else:
+                return Result.error(message = str(resp.error.detail))
+
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def update_proc_status(self, **kwargs):
+        ''' update the status of reduction
+
+        parameter kwargs:
+            id : [int],
+            status : [int]
+
+        return csst_dfs_common.models.Result
+        '''
+        id = get_parameter(kwargs, "id")
+        status = get_parameter(kwargs, "status")
+
+        try:
+            resp,_ = self.stub.UpdateProcStatus.with_call(
+                level0prc_pb2.UpdateProcStatusReq(id=id, status=status),
+                metadata = get_auth_headers()
+            )
+            if resp.success:
+                return Result.ok_data()
+            else:
+                return Result.error(message = str(resp.error.detail))
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def write(self, **kwargs):
+        ''' insert a level0 procedure record into database
+ 
+        parameter kwargs:
+            level0_id : [str]
+            pipeline_id : [str]
+            prc_module : [str]
+            params_file_path : [str]
+            prc_status : [int]
+            prc_time : [str]
+            result_file_path : [str]
+        return csst_dfs_common.models.Result
+        '''   
+
+        rec = level0prc_pb2.Level0PrcRecord(
+            id = 0,
+            level0_id = get_parameter(kwargs, "level0_id"),
+            pipeline_id = get_parameter(kwargs, "pipeline_id"),
+            prc_module = get_parameter(kwargs, "prc_module"),
+            params_file_path = get_parameter(kwargs, "params_file_path"),
+            prc_status = get_parameter(kwargs, "prc_status", -1),
+            prc_time = get_parameter(kwargs, "prc_time"),
+            result_file_path = get_parameter(kwargs, "result_file_path")
+        )
+        req = level0prc_pb2.WriteLevel0PrcReq(record = rec)
+        try:
+            resp,_ = self.stub.Write.with_call(req,metadata = get_auth_headers())
+            if resp.success:
+                return Result.ok_data(data = Level0PrcRecord().from_proto_model(resp.record))
+            else:
+                return Result.error(message = str(resp.error.detail))
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+   
+

csst_dfs_api_cluster/msc/level1prc.py

+import grpc
+
+from csst_dfs_commons.models import Result
+from csst_dfs_commons.models.common import from_proto_model_list
+from csst_dfs_commons.models.msc import Level1PrcRecord
+
+from csst_dfs_proto.msc.level1prc import level1prc_pb2, level1prc_pb2_grpc
+
+from ..common.service import ServiceProxy
+from ..common.utils import *
+
+class Level1PrcApi(object):
+    def __init__(self):
+        self.stub = level1prc_pb2_grpc.Level1PrcSrvStub(ServiceProxy().channel())
+
+    def find(self, **kwargs):
+        ''' retrieve level1 procedure records from database
+
+        parameter kwargs:
+            level1_id: [str]
+            pipeline_id: [str]
+            prc_module: [str]
+            prc_status : [int]
+
+        return: csst_dfs_common.models.Result
+        '''
+        try:
+            resp, _ =  self.stub.Find.with_call(level1prc_pb2.FindLevel1PrcReq(
+                level1_id = get_parameter(kwargs, "level1_id"),
+                pipeline_id = get_parameter(kwargs, "pipeline_id"),
+                prc_module = get_parameter(kwargs, "prc_module"),
+                prc_status = get_parameter(kwargs, "prc_status"),
+                other_conditions = {"test":"cnlab.test"}
+            ),metadata = get_auth_headers())
+
+            if resp.success:
+                return Result.ok_data(data = from_proto_model_list(Level1PrcRecord, resp.records)).append("totalCount", resp.totalCount)
+            else:
+                return Result.error(message = str(resp.error.detail))
+
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def update_proc_status(self, **kwargs):
+        ''' update the status of reduction
+
+        parameter kwargs:
+            id : [int],
+            status : [int]
+
+        return csst_dfs_common.models.Result
+        '''
+        id = get_parameter(kwargs, "id")
+        status = get_parameter(kwargs, "status")
+
+        try:
+            resp,_ = self.stub.UpdateProcStatus.with_call(
+                level1prc_pb2.UpdateProcStatusReq(id=id, status=status),
+                metadata = get_auth_headers()
+            )
+            if resp.success:
+                return Result.ok_data()
+            else:
+                return Result.error(message = str(resp.error.detail))
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def write(self, **kwargs):
+        ''' insert a level1 procedure record into database
+ 
+        parameter kwargs:
+            level1_id : [int]
+            pipeline_id : [str]
+            prc_module : [str]
+            params_file_path : [str]
+            prc_status : [int]
+            prc_time : [str]
+            result_file_path : [str]
+        return csst_dfs_common.models.Result
+        '''   
+
+        rec = level1prc_pb2.Level1PrcRecord(
+            id = 0,
+            level1_id = get_parameter(kwargs, "level1_id"),
+            pipeline_id = get_parameter(kwargs, "pipeline_id"),
+            prc_module = get_parameter(kwargs, "prc_module"),
+            params_file_path = get_parameter(kwargs, "params_file_path"),
+            prc_status = get_parameter(kwargs, "prc_status", -1),
+            prc_time = get_parameter(kwargs, "prc_time"),
+            result_file_path = get_parameter(kwargs, "result_file_path")
+        )
+        req = level1prc_pb2.WriteLevel1PrcReq(record = rec)
+        try:
+            resp,_ = self.stub.Write.with_call(req,metadata = get_auth_headers())
+            if resp.success:
+                return Result.ok_data(data = Level1PrcRecord().from_proto_model(resp.record))
+            else:
+                return Result.error(message = str(resp.error.detail))
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+   
+

csst_dfs_api_cluster/sls/__init__.py

+from .calmerge import CalMergeApi
+from .level0 import Level0DataApi
+from .level0prc import Level0PrcApi
 from .level1 import Level1DataApi
+from .level1prc import Level1PrcApi
 from .level2spectra import Level2SpectraApi
\ No newline at end of file

csst_dfs_api_cluster/sls/calmerge.py

+import grpc
+
+from csst_dfs_commons.models import Result
+from csst_dfs_commons.models.common import from_proto_model_list
+from csst_dfs_commons.models.sls import CalMergeRecord
+
+from csst_dfs_proto.sls.calmerge import calmerge_pb2, calmerge_pb2_grpc
+
+from ..common.service import ServiceProxy
+from ..common.utils import *
+
+class CalMergeApi(object):
+    def __init__(self):
+        self.stub = calmerge_pb2_grpc.CalMergeSrvStub(ServiceProxy().channel())
+
+    def get_latest_by_l0(self, **kwargs):
+        ''' retrieve calibration merge records from database by level0 data
+
+        parameter kwargs:
+            level0_id: [str]
+            ref_type: [str]
+
+        return: csst_dfs_common.models.Result
+        '''
+        try:
+            resp, _ =  self.stub.GetLatestByL0.with_call(calmerge_pb2.GetLatestByL0Req(
+                level0_id = get_parameter(kwargs, "level0_id"),
+                ref_type = get_parameter(kwargs, "ref_type")),
+            metadata = get_auth_headers())
+
+            if resp.record.id == 0:
+                return Result.error(message=f"not found")  
+
+            return Result.ok_data(data=CalMergeRecord().from_proto_model(resp.record))
+
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def find(self, **kwargs):
+        ''' retrieve calibration merge records from database
+
+        parameter kwargs:
+            detector_no: [str]
+            ref_type: [str]
+            obs_time: (start,end)
+            qc1_status : [int]
+            prc_status : [int]
+            file_name: [str]
+            limit: limits returns the number of records,default 0:no-limit
+
+        return: csst_dfs_common.models.Result
+        '''
+        try:
+            resp, _ =  self.stub.Find.with_call(calmerge_pb2.FindCalMergeReq(
+                detector_no = get_parameter(kwargs, "detector_no"),
+                ref_type = get_parameter(kwargs, "ref_type"),
+                exp_time_start = get_parameter(kwargs, "obs_time", [None, None])[0],
+                exp_time_end = get_parameter(kwargs, "obs_time", [None, None])[1],                
+                qc1_status = get_parameter(kwargs, "qc1_status"),
+                prc_status = get_parameter(kwargs, "prc_status"),
+                file_name = get_parameter(kwargs, "file_name"),
+                limit = get_parameter(kwargs, "limit"),
+                other_conditions = {"test":"cnlab.test"}
+            ),metadata = get_auth_headers())
+
+            if resp.success:
+                return Result.ok_data(data=from_proto_model_list(CalMergeRecord,resp.records)).append("totalCount", resp.totalCount)
+            else:
+                return Result.error(message = str(resp.error.detail))
+
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def get(self, **kwargs):
+        '''  fetch a record from database
+
+        :param kwargs: Parameter dictionary, key items support:
+            id : [int]
+        
+        :returns: csst_dfs_common.models.Result
+        '''
+        try:
+            id = get_parameter(kwargs, "id", 0)
+            cal_id = get_parameter(kwargs, "cal_id", "")
+            resp, _ =  self.stub.Get.with_call(calmerge_pb2.GetCalMergeReq(
+                id = id,
+                cal_id = cal_id
+            ),metadata = get_auth_headers())
+
+            if resp.record.id == 0:
+                return Result.error(message=f"not found")  
+
+            return Result.ok_data(data=CalMergeRecord().from_proto_model(resp.record))
+           
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))   
+
+    def update_qc1_status(self, **kwargs):
+        ''' update the status of reduction
+
+        parameter kwargs:
+            id : [int],
+            cal_id = cal_id,
+            status : [int]
+
+        return csst_dfs_common.models.Result
+        '''
+        id = get_parameter(kwargs, "id", 0)
+        cal_id = get_parameter(kwargs, "cal_id", "")
+        status = get_parameter(kwargs, "status")
+
+        try:
+            resp,_ = self.stub.UpdateQc1Status.with_call(
+                calmerge_pb2.UpdateQc1StatusReq(
+                    id = id, 
+                    cal_id = cal_id,
+                    status=status),
+                metadata = get_auth_headers()
+            )
+            if resp.success:
+                return Result.ok_data()
+            else:
+                return Result.error(message = str(resp.error.detail))
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def update_proc_status(self, **kwargs):
+        ''' update the status of reduction
+
+        parameter kwargs:
+            id : [int],
+            cal_id: [str],
+            status : [int]
+
+        return csst_dfs_common.models.Result
+        '''
+        id = get_parameter(kwargs, "id", 0)
+        cal_id = get_parameter(kwargs, "cal_id", "")
+        status = get_parameter(kwargs, "status")
+
+        try:
+            resp,_ = self.stub.UpdateProcStatus.with_call(
+                calmerge_pb2.UpdateProcStatusReq(
+                    id = id,
+                    cal_id = cal_id,
+                    status=status),
+                metadata = get_auth_headers()
+            )
+            if resp.success:
+                return Result.ok_data()
+            else:
+                return Result.error(message = str(resp.error.detail))
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def write(self, **kwargs):
+        ''' insert a calibration merge record into database
+ 
+        parameter kwargs:
+            cal_id : [str],
+            detector_no : [str]
+            ref_type : [str]
+            obs_time : [str]
+            exp_time : [float]
+            prc_status : [int]
+            prc_time : [str]
+            filename : [str]
+            file_path : [str]
+            level0_ids : [list]
+        return csst_dfs_common.models.Result
+        '''   
+
+        rec = calmerge_pb2.CalMergeRecord(
+            id = 0,
+            cal_id = get_parameter(kwargs, "cal_id"),
+            detector_no = get_parameter(kwargs, "detector_no"),
+            ref_type = get_parameter(kwargs, "ref_type"),
+            obs_time = get_parameter(kwargs, "obs_time"),
+            exp_time = get_parameter(kwargs, "exp_time"),
+            filename = get_parameter(kwargs, "filename"),
+            file_path = get_parameter(kwargs, "file_path"),
+            prc_status = get_parameter(kwargs, "prc_status",-1),
+            prc_time = get_parameter(kwargs, "prc_time"),
+            level0_ids = get_parameter(kwargs, "level0_ids", [])
+        )
+        req = calmerge_pb2.WriteCalMergeReq(record = rec)
+        try:
+            resp,_ = self.stub.Write.with_call(req,metadata = get_auth_headers())
+            if resp.success:
+                return Result.ok_data(data=CalMergeRecord().from_proto_model(resp.record))
+            else:
+                return Result.error(message = str(resp.error.detail))
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+

csst_dfs_api_cluster/sls/level0.py

+import grpc
+
+from csst_dfs_commons.models import Result
+from csst_dfs_commons.models.common import from_proto_model_list
+from csst_dfs_commons.models.sls import Level0Record
+
+from csst_dfs_proto.sls.level0 import level0_pb2, level0_pb2_grpc
+
+from ..common.service import ServiceProxy
+from ..common.utils import *
+
+class Level0DataApi(object):
+    def __init__(self):
+        self.stub = level0_pb2_grpc.Level0SrvStub(ServiceProxy().channel())
+
+    def find(self, **kwargs):
+        ''' retrieve level0 records from database
+
+        parameter kwargs:
+            obs_id: [str]
+            detector_no: [str]
+            obs_type: [str]
+            obs_time : (start, end),
+            qc0_status : [int],
+            prc_status : [int],
+            file_name: [str]
+            limit: limits returns the number of records,default 0:no-limit
+
+        return: csst_dfs_common.models.Result
+        '''
+        try:
+            resp, _ =  self.stub.Find.with_call(level0_pb2.FindLevel0DataReq(
+                obs_id = get_parameter(kwargs, "obs_id"),
+                detector_no = get_parameter(kwargs, "detector_no"),
+                obs_type = get_parameter(kwargs, "obs_type"),
+                exp_time_start = get_parameter(kwargs, "obs_time", [None, None])[0],
+                exp_time_end = get_parameter(kwargs, "obs_time", [None, None])[1],
+                qc0_status = get_parameter(kwargs, "qc0_status"),
+                prc_status = get_parameter(kwargs, "prc_status"),
+                file_name = get_parameter(kwargs, "file_name"),
+                limit = get_parameter(kwargs, "limit", 0),
+                other_conditions = {"test":"cnlab.test"}
+            ),metadata = get_auth_headers())
+
+            if resp.success:
+                return Result.ok_data(data=from_proto_model_list(Level0Record, resp.records)).append("totalCount", resp.totalCount)
+            else:
+                return Result.error(message = str(resp.error.detail))
+
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def get(self, **kwargs):
+        '''  fetch a record from database
+
+        parameter kwargs:
+            id : [int],
+            level0_id: [str]
+
+        return csst_dfs_common.models.Result
+        '''
+        try:
+            id = get_parameter(kwargs, "id")
+            level0_id = get_parameter(kwargs, "level0_id")
+            resp, _ =  self.stub.Get.with_call(level0_pb2.GetLevel0DataReq(
+                id = id,
+                level0_id = level0_id
+            ),metadata = get_auth_headers())
+
+            if resp.record is None or resp.record.id == 0:
+                return Result.error(message=f"not found")  
+
+            return Result.ok_data(data = Level0Record().from_proto_model(resp.record))
+           
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))   
+
+    def update_proc_status(self, **kwargs):
+        ''' update the status of reduction
+
+        parameter kwargs:
+            id : [int],
+            level0_id: [str],
+            status : [int]
+
+        return csst_dfs_common.models.Result
+        '''
+        id = get_parameter(kwargs, "id")
+        level0_id = get_parameter(kwargs, "level0_id")
+        status = get_parameter(kwargs, "status")
+        try:
+            resp,_ = self.stub.UpdateProcStatus.with_call(
+                level0_pb2.UpdateProcStatusReq(
+                    id=id,
+                    level0_id = level0_id,
+                    status=status),
+                metadata = get_auth_headers()
+            )
+            if resp.success:
+                return Result.ok_data()
+            else:
+                return Result.error(message = str(resp.error.detail))
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def update_qc0_status(self, **kwargs):
+        ''' update the status of QC0
+        
+        parameter kwargs:
+            id : [int],
+            level0_id: [str],
+            status : [int]
+        '''        
+        id = get_parameter(kwargs, "id")
+        level0_id = get_parameter(kwargs, "level0_id")
+        status = get_parameter(kwargs, "status")
+        try:
+            resp,_ = self.stub.UpdateQc0Status.with_call(
+                level0_pb2.UpdateQc0StatusReq( 
+                    id=id,
+                    level0_id = level0_id,
+                    status=status),
+                metadata = get_auth_headers()
+            )
+            if resp.success:
+                return Result.ok_data()
+            else:
+                return Result.error(message = str(resp.error.detail))
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def write(self, **kwargs):
+        ''' insert a level0 data record into database
+ 
+        parameter kwargs:
+            obs_id = [str]
+            detector_no = [str]
+            obs_type = [str]        
+            obs_time = [str]
+            exp_time = [int]
+            detector_status_id = [int]
+            filename = [str]
+            file_path = [str]
+        return: csst_dfs_common.models.Result
+        '''          
+        rec = level0_pb2.Level0Record(
+            obs_id = get_parameter(kwargs, "obs_id"),
+            detector_no = get_parameter(kwargs, "detector_no"),
+            obs_type = get_parameter(kwargs, "obs_type"),
+            obs_time = get_parameter(kwargs, "obs_time"),
+            exp_time = get_parameter(kwargs, "exp_time"),
+            detector_status_id = get_parameter(kwargs, "detector_status_id"),
+            filename = get_parameter(kwargs, "filename"),
+            file_path = get_parameter(kwargs, "file_path")
+        )
+        req = level0_pb2.WriteLevel0DataReq(record = rec)
+        try:
+            resp,_ = self.stub.Write.with_call(req,metadata = get_auth_headers())
+            if resp.success:
+                return Result.ok_data(data = Level0Record().from_proto_model(resp.record))
+            else:
+                return Result.error(message = str(resp.error.detail))
+    
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+

csst_dfs_api_cluster/sls/level0prc.py

+import grpc
+
+from csst_dfs_commons.models import Result
+from csst_dfs_commons.models.common import from_proto_model_list
+from csst_dfs_commons.models.sls import Level0PrcRecord
+
+from csst_dfs_proto.sls.level0prc import level0prc_pb2, level0prc_pb2_grpc
+
+from ..common.service import ServiceProxy
+from ..common.utils import *
+
+class Level0PrcApi(object):
+    def __init__(self):
+        self.stub = level0prc_pb2_grpc.Level0PrcSrvStub(ServiceProxy().channel())
+
+    def find(self, **kwargs):
+        ''' retrieve level0 procedure records from database
+
+        parameter kwargs:
+            level0_id: [str]
+            pipeline_id: [str]
+            prc_module: [str]
+            prc_status : [int]
+
+        return: csst_dfs_common.models.Result
+        '''
+        try:
+            resp, _ =  self.stub.Find.with_call(level0prc_pb2.FindLevel0PrcReq(
+                level0_id = get_parameter(kwargs, "level0_id"),
+                pipeline_id = get_parameter(kwargs, "pipeline_id"),
+                prc_module = get_parameter(kwargs, "prc_module"),
+                prc_status = get_parameter(kwargs, "prc_status"),
+                other_conditions = {"test":"cnlab.test"}
+            ),metadata = get_auth_headers())
+
+            if resp.success:
+                return Result.ok_data(data = from_proto_model_list(Level0PrcRecord, resp.records)).append("totalCount", resp.totalCount)
+            else:
+                return Result.error(message = str(resp.error.detail))
+
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def update_proc_status(self, **kwargs):
+        ''' update the status of reduction
+
+        parameter kwargs:
+            id : [int],
+            status : [int]
+
+        return csst_dfs_common.models.Result
+        '''
+        id = get_parameter(kwargs, "id")
+        status = get_parameter(kwargs, "status")
+
+        try:
+            resp,_ = self.stub.UpdateProcStatus.with_call(
+                level0prc_pb2.UpdateProcStatusReq(id=id, status=status),
+                metadata = get_auth_headers()
+            )
+            if resp.success:
+                return Result.ok_data()
+            else:
+                return Result.error(message = str(resp.error.detail))
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def write(self, **kwargs):
+        ''' insert a level0 procedure record into database
+ 
+        parameter kwargs:
+            level0_id : [str]
+            pipeline_id : [str]
+            prc_module : [str]
+            params_file_path : [str]
+            prc_status : [int]
+            prc_time : [str]
+            result_file_path : [str]
+        return csst_dfs_common.models.Result
+        '''   
+
+        rec = level0prc_pb2.Level0PrcRecord(
+            id = 0,
+            level0_id = get_parameter(kwargs, "level0_id"),
+            pipeline_id = get_parameter(kwargs, "pipeline_id"),
+            prc_module = get_parameter(kwargs, "prc_module"),
+            params_file_path = get_parameter(kwargs, "params_file_path"),
+            prc_status = get_parameter(kwargs, "prc_status", -1),
+            prc_time = get_parameter(kwargs, "prc_time"),
+            result_file_path = get_parameter(kwargs, "result_file_path")
+        )
+        req = level0prc_pb2.WriteLevel0PrcReq(record = rec)
+        try:
+            resp,_ = self.stub.Write.with_call(req,metadata = get_auth_headers())
+            if resp.success:
+                return Result.ok_data(data = Level0PrcRecord().from_proto_model(resp.record))
+            else:
+                return Result.error(message = str(resp.error.detail))
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+   
+

csst_dfs_api_cluster/sls/level1prc.py

+import grpc
+
+from csst_dfs_commons.models import Result
+from csst_dfs_commons.models.common import from_proto_model_list
+from csst_dfs_commons.models.sls import Level1PrcRecord
+
+from csst_dfs_proto.sls.level1prc import level1prc_pb2, level1prc_pb2_grpc
+
+from ..common.service import ServiceProxy
+from ..common.utils import *
+
+class Level1PrcApi(object):
+    def __init__(self):
+        self.stub = level1prc_pb2_grpc.Level1PrcSrvStub(ServiceProxy().channel())
+
+    def find(self, **kwargs):
+        ''' retrieve level1 procedure records from database
+
+        parameter kwargs:
+            level1_id: [str]
+            pipeline_id: [str]
+            prc_module: [str]
+            prc_status : [int]
+
+        return: csst_dfs_common.models.Result
+        '''
+        try:
+            resp, _ =  self.stub.Find.with_call(level1prc_pb2.FindLevel1PrcReq(
+                level1_id = get_parameter(kwargs, "level1_id"),
+                pipeline_id = get_parameter(kwargs, "pipeline_id"),
+                prc_module = get_parameter(kwargs, "prc_module"),
+                prc_status = get_parameter(kwargs, "prc_status"),
+                other_conditions = {"test":"cnlab.test"}
+            ),metadata = get_auth_headers())
+
+            if resp.success:
+                return Result.ok_data(data = from_proto_model_list(Level1PrcRecord, resp.records)).append("totalCount", resp.totalCount)
+            else:
+                return Result.error(message = str(resp.error.detail))
+
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def update_proc_status(self, **kwargs):
+        ''' update the status of reduction
+
+        parameter kwargs:
+            id : [int],
+            status : [int]
+
+        return csst_dfs_common.models.Result
+        '''
+        id = get_parameter(kwargs, "id")
+        status = get_parameter(kwargs, "status")
+
+        try:
+            resp,_ = self.stub.UpdateProcStatus.with_call(
+                level1prc_pb2.UpdateProcStatusReq(id=id, status=status),
+                metadata = get_auth_headers()
+            )
+            if resp.success:
+                return Result.ok_data()
+            else:
+                return Result.error(message = str(resp.error.detail))
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+    def write(self, **kwargs):
+        ''' insert a level1 procedure record into database
+ 
+        parameter kwargs:
+            level1_id : [int]
+            pipeline_id : [str]
+            prc_module : [str]
+            params_file_path : [str]
+            prc_status : [int]
+            prc_time : [str]
+            result_file_path : [str]
+        return csst_dfs_common.models.Result
+        '''   
+
+        rec = level1prc_pb2.Level1PrcRecord(
+            id = 0,
+            level1_id = get_parameter(kwargs, "level1_id"),
+            pipeline_id = get_parameter(kwargs, "pipeline_id"),
+            prc_module = get_parameter(kwargs, "prc_module"),
+            params_file_path = get_parameter(kwargs, "params_file_path"),
+            prc_status = get_parameter(kwargs, "prc_status", -1),
+            prc_time = get_parameter(kwargs, "prc_time"),
+            result_file_path = get_parameter(kwargs, "result_file_path")
+        )
+        req = level1prc_pb2.WriteLevel1PrcReq(record = rec)
+        try:
+            resp,_ = self.stub.Write.with_call(req,metadata = get_auth_headers())
+            if resp.success:
+                return Result.ok_data(data = Level1PrcRecord().from_proto_model(resp.record))
+            else:
+                return Result.error(message = str(resp.error.detail))
+        except grpc.RpcError as e:
+            return Result.error(message="%s:%s" % (e.code().value, e.details))
+
+   
+

tests/test_common_catalog.py

-import os
-import unittest
-from astropy.io import fits
-
-from csst_dfs_api_cluster.common.catalog import CatalogApi
-
-class CommonEphemTestCase(unittest.TestCase):
-
-    def setUp(self):
-        self.api = CatalogApi()
-
-    def test_gaia3_query(self):
-        recs = self.api.gaia3_query(ra=222.1, dec=40, radius=0.5, min_mag=-1, max_mag=-1, obstime = -1, limit = 2)
-        print('find:', recs)

tests/test_facility_cal_merge.py

-import os
-import unittest
-from astropy.io import fits
-
-from csst_dfs_api_cluster.facility.calmerge import CalMergeApi
-
-class CalMergeApiTestCase(unittest.TestCase):
-
-    def setUp(self):
-        self.api = CalMergeApi()
-
-    def test_find(self):
-        recs = self.api.find(detector_no='CCD01',
-            ref_type = "bias",
-            obs_time = ("2021-06-01 11:12:13","2021-06-08 11:12:13"))
-        print('find:', recs)
-
-    def test_get_latest_by_l0(self):
-        rec = self.api.get_latest_by_l0(level0_id='00000002401', ref_type = "bias")
-        print('get_latest_by_l0:', rec)
-        
-    def test_get(self):
-        rec = self.api.get(id = 4)
-        print('get:', rec)
-
-    def test_update_proc_status(self):
-        rec = self.api.update_proc_status(id = 3, status = -1)
-        print('update_proc_status:', rec)
-
-    def test_update_qc1_status(self):
-        rec = self.api.update_qc1_status(id = 3, status = -1)
-        print('update_qc1_status:', rec)    
-
-    def test_write(self):
-        rec = self.api.write(
-            cal_id = "10000X03",
-            detector_no='03', 
-            ref_type = "bias",
-            obs_time = "2021-06-04 11:12:13",
-            exp_time = 150,
-            filename = "/opt/dddasd.params",
-            file_path = "/opt/dddasd.fits",
-            prc_status = 3,
-            prc_time = '2021-06-04 11:12:13',
-            level0_ids = ['1','2','3','4'])
-        print('write:', rec)
\ No newline at end of file